So testen Sie Ihr JavaScript mit Selenium WebDriver und Mokka

Kernpunkte

• mocha.js ist ein featurereiches JavaScript-Test-Framework, das auf Node.js basiert und zum Schreiben von JavaScript-Funktionstests in Kombination mit Selenium WebDriver 3 und NodeJS verwendet werden kann. Dies erfordert Vertrautheit mit den Grundlagen von NodeJS und JavaScript -Programmiersprachen.
• Mokka bietet eine API zum Erstellen von Testcode in Testsuiten und Testfallmodule, um die Ausführung und die Erzeugung von Bericht zu ermöglichen. Es unterstützt Testsuite -Setup- und Teardown -Funktionen sowie Testfall -Setup- und -Reardown -Funktionen.
• selenium webdriver ist eine Bibliothek, die Webbrowser steuert und das Benutzerverhalten simuliert und in Mochajs integriert werden kann. Es bietet eine spezifische API der Sprachbibliothek mit dem Namen "Bindung", um den Browser zu steuern.
• asynchronisierte Funktionen, die mit Mokka verwendet werden, müssen korrekt behandelt werden, um unerwartete Ergebnisse zu vermeiden. Dies kann durchgeführt werden, indem die Funktion "Fertig" an die Rückrufkette weitergegeben oder ein Versprechen zurückgegeben wird.
• Andere Frameworks wie Webdriverio, Prospractor und CodesptJs bieten Wrapper -Lösungen, die einige Konfigurationen für Benutzer ausblenden und eine verbesserte Versprechungsverarbeitung für ein besseres Skripterlebnis bieten.

Dieser Artikel wurde ursprünglich auf TestProject veröffentlicht.

Wenn Sie Funktionstests in JavaScript schreiben möchten, bietet dieses Tutorial UI -Automatisierungsingenieure das perfekte strukturierte Referenzmaterial für JavaScript -Tests mit Selenium WebDriver 3, Mokka und NodeJs.

JavaScript ist heute eine allgegenwärtige Websprache, die seine "berüchtigte" Vergangenheit zu überwinden scheint und nicht nur für Clients, sondern auch für Server zu einer zuverlässigeren Plattform geworden ist. Mocha.js (oder kurz Mokka) ist ein featurereiches JavaScript-Test-Framework, das auf Node.js.

Hinweis: Um dieses JavaScript -Tutorial zu lernen, müssen Sie mit den Grundlagen von NodeJs und JavaScript -Programmiersprachen vertraut sein.

Tutorial -Übersicht:

1. Mokka -Test -Build

• Einführung
• Installation
• Installieren des Chai -Assertion -Moduls
• Testsuite und Testfallstruktur
• Erstellen Sie Tests mit Mocha
• Testsuiten und Testfälle mit Mokka
• Synchronisation des asynchronen Testcodes
verwalten

Verwenden des JavaScript -Seleniums 3 -API, das in Mochajs integriert ist

Einführung in Selen
selenium installation
Webdriver Construct
Integrieren Sie Mochajs in Selenium WebDriver 3

Version verwendet:

• Knotenversion: 6.10.1 (LTS)
• Mocha: 2.5.3
• WebDriverJS: 3.3.0

1. Erstellen Sie Tests mit Mocha

Mocha Einführung

Wie bereits erwähnt, ist Mocha ein JavaScript -Test -Framework, das Tests auf dem Knoten ausführt. Mokka wird in Form eines Knotenpakets (über NPM) bereitgestellt, sodass Sie den Standard "Assert" -Funktionen des Knotens durch eine Assertion -Bibliothek wie Chaijs ersetzen können. Darüber hinaus hat Mokka mehrere Komponenten ähnlich wie Jasmine, ein weiteres beliebtes Testautomatisierungsrahmen, das wir in der Trendstudie mit Front-End- und Unit-Testautomatisierung erwähnt haben).

Mocha bietet eine API, mit der eine Möglichkeit zum Erstellen von Testcode in Testsuiten und Testfallmodule für die Ausführung angegeben und dann Testberichte generiert werden. Mocha bietet zwei Betriebsmodi: Befehlszeile (CLI) oder Programmierung (Mokka -API).

Installation Mocha

Wenn Sie Mocha in der CLI verwenden möchten, sollten Sie es global als node.js.

<code>npm install -g mocha</code>

Installieren des Chai -Assertion -Moduls

<code>npm install --save chai</code>

Mit der Option

–Save wird die Module im Rahmen des Projekts und nicht global installiert.

Testsuite und Testfallstruktur

In Mocha wird die Testsuite durch das Schlüsselwort "Beschreiben" definiert, das eine Rückruffunktion akzeptiert. Testsuiten können Sub-/Innen -Testsuiten enthalten, die ihre eigenen Subtest -Suiten enthalten können, und so weiter. Der Testfall wird durch die Funktion "IT" dargestellt, die eine Rückruffunktion akzeptiert und den Testcode enthält.

Mokka unterstützt Testsuite -Einstellungen und Testfalleinstellungen. "Before" bedeutet Testsuite -Einstellungen, während "Beforeach" Testfalleinstellungen bedeutet. "Beforeach" ist eigentlich ein übliches Setup für jeden Anwendungsfall in der Suite und wird vor jedem Anwendungsfall ausgeführt.

wie beim Setup unterstützt Mokka Testsuiten und Testfall -Abrechnungsfunktionen. "After" Means Test Suite Demontage und "Afterach" bedeutet, dass diese beiden Funktionen nach der Testsuite bzw. jedem Testfall getestet werden.

Erstellen Sie eine Datei, die die Testsuite wie test_suite.js "hostet", und schreiben Sie Folgendes in sie

describe("Inner Suite 1", function(){

    before(function(){

        // 在测试套件执行之前执行某些操作
        // 无论是否有失败的用例

    });

    after(function(){

        // 测试套件执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    beforeEach(function(){

        // 在测试用例执行之前执行某些操作
        // 无论是否有失败的用例

    });

    afterEach(function(){

        // 测试用例执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    it("Test-1", function(){

        // 测试代码
        // 断言

    });

    it("Test-2", function(){

        // 测试代码
        // 断言

    });

    it("Test-3", function(){

        // 测试代码
        // 断言

    });

});

Mokka -Testsuite und Testfälle ausführen

Mokka unterstützt drei Testausführungsmethoden: die gesamte Testsuite -Datei, die im "Grep" -Modus gefilterte Tests und die Testsuche (rekursive Option) im Verzeichnisbaum Grep Filtering

Führen Sie die gesamte Testsuite -Datei aus:

mocha /path/to/test_suite.js

Führen Sie eine bestimmte Suite oder einen bestimmten Test aus einer bestimmten Testsuite -Datei aus.

Wenn ein Kit ausgewählt ist, werden alle Unterkits und/oder Tests durchgeführt.

mocha -g “Test-2” /path/to/test_suite.js

Führen Sie eine bestimmte Suite- oder Testdatei aus, indem Sie rekursiv im Verzeichnisbaum suchen.

mocha --recursive -g “Test-2” /directory/

CLI -Optionen für Erweiterungen:

mocha --help

Synchronisation des asynchronen Testcodes

verwalten

Wenn Sie asynchrone Funktionen mit Mokka verwenden und nicht richtig behandelt werden, haben Sie möglicherweise Probleme mit der Bewältigung von Problemen. Wenn Sie in Ihren Testfällen (z. B. HTTP -Anforderungen, Dateien, Selen usw.) asynchronen Code verwenden möchten, befolgen Sie die folgenden Richtlinien, um unerwartete Ergebnisse zu überwinden:

1. Function Function

In der Testfunktion (IT) müssen Sie die Fertigfunktion in die Rückrufkette übergeben - dies stellt sicher, dass sie nach Ihrem letzten Schritt ausgeführt wird.

Das folgende Beispiel unterstreicht die Fertigfunktion. In diesem Fall tritt am Ende der Testfunktion eine Zeitüberschreitung von drei Sekunden auf.

<code>npm install -g mocha</code>

2. kehren Sie zu Versprechen
zurück

Rückgabeversprechen ist eine andere Möglichkeit, um sicherzustellen, dass Mokka bei Verwendung einer asynchronen Funktion alle Codezeilen ausgeführt hat (in diesem Fall ist die Funktion "Fertig" nicht erforderlich.)

<code>npm install --save chai</code>

2. JavaScript Selenium 3 Integration mit Mochajs

Einführung in Selen

Selenium ist eine Bibliothek, die Webbrowser steuert und das Benutzerverhalten simuliert. Insbesondere bietet Selenium den Benutzern eine spezifische API der Sprachbibliothek mit dem Namen "Binding". "Bindung" fungiert als Client, um Anforderungen an Zwischenkomponenten auszuführen, und fungiert als Server, um den Browser letztendlich zu steuern.

Selenium -API oder Bindung existiert jetzt in allen populären Entwicklungssprachen. Alle Sprachimplementierungen stimmen nun zu, die Konsistenz in den Konventionen der API -Funktion zu erhalten.

Die Zwischenkomponenten können der tatsächliche Webdriver sein, Selenium-Standalone-Server, der lokal in jedem Selenium-Paket zu finden ist, sowie die nativen Browser-Kontrolltreiber des Verkäufers-wie der Geckodriver von Mozilla, Chroms Chromedriver usw. usw. Darüber hinaus kommuniziert Selenium WebDriver mit Browser -Treibern über "JSONWIRED Protocol" und wird zum W3C -Webstandard.

selenium installation

Wir werden schnell etwas über die Implementierung von Selen und NodeJS erfahren, bevor wir uns mit der Integration von Selen und Mochajs befassen.

Um die Selenium -API von JavaScript (oder Selenium JavaScript) zu verwenden, sollten wir das entsprechende Modul installieren:

describe("Inner Suite 1", function(){

    before(function(){

        // 在测试套件执行之前执行某些操作
        // 无论是否有失败的用例

    });

    after(function(){

        // 测试套件执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    beforeEach(function(){

        // 在测试用例执行之前执行某些操作
        // 无论是否有失败的用例

    });

    afterEach(function(){

        // 测试用例执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    it("Test-1", function(){

        // 测试代码
        // 断言

    });

    it("Test-2", function(){

        // 测试代码
        // 断言

    });

    it("Test-3", function(){

        // 测试代码
        // 断言

    });

});

Zu diesem Zeitpunkt sollte klar sein, dass JavaScript Selenium WebDriver auch als WebdriverJS bezeichnet werden kann (wenn auch nicht in NPM). WebDriveJS unterscheidet sich von anderen Bibliotheken/Modulen (wie Webdriverio, Prospractor usw.). Selenium-Webriver ist die offizielle Open-Source-Basis-JavaScript-Selenium-Bibliothek, während andere Bibliotheken Wrapper-Bibliotheken/Frameworks sind, die auf der WebdriverJS-API basieren und behaupten, die Verfügbarkeit und Wartung zu verbessern.

Im NodeJS -Code werden Module auf folgende Weise verwendet:

mocha /path/to/test_suite.js

Webdriver Construct

Um Selen verwenden zu können, sollten wir das entsprechende "Webdriver" -Objekt erstellen, das dann unseren Browser steuert. Im Folgenden können wir sehen, wie wir das "Builder" -Muster verwenden, um Webdriver -Objekte zu erstellen, indem wir mehrere Funktionen verknüpfen.

Builder mit Optionen

mocha -g “Test-2” /path/to/test_suite.js

Im obigen Code haben wir ein Webdriver -Objekt erfolgreich erstellt, das Konfigurationen mehrerer Browser aggregiert (beachten Sie die "Optionen" -Methode), obwohl die Forbrowser () -Methode explizit Firefox festlegt.

Der Benutzer kann die Variable der selenium_browser -Umgebung zur Laufzeit festlegen, um den gewünschten Browser festzulegen. Es wird alle von Forbrowser festgelegten Optionen überschreiben, da wir mehrere Browserfunktionen über Set -Optionen festgelegt haben.

Browsereigenschaften können je nach getestetem Browser mehrere Informationsarten enthalten. In den Eigenschaften von Mozilla können wir beispielsweise die erforderliche "Profil" -Konfiguration wie folgt einstellen:

<code>npm install -g mocha</code>

Dann können wir im Builder -Snippet oben hinzufügen:

<code>npm install --save chai</code>

Builder mit Funktionen

Die Dokumentation von Selenium WebDriver JavaScript API beschreibt verschiedene Möglichkeiten, einen Webdriver zu erstellen. Ein weiterer möglicher Ansatz besteht darin, alle erforderlichen Treiberkonfigurationen auf Funktionen festzulegen:

describe("Inner Suite 1", function(){

    before(function(){

        // 在测试套件执行之前执行某些操作
        // 无论是否有失败的用例

    });

    after(function(){

        // 测试套件执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    beforeEach(function(){

        // 在测试用例执行之前执行某些操作
        // 无论是否有失败的用例

    });

    afterEach(function(){

        // 测试用例执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    it("Test-1", function(){

        // 测试代码
        // 断言

    });

    it("Test-2", function(){

        // 测试代码
        // 断言

    });

    it("Test-3", function(){

        // 测试代码
        // 断言

    });

});

Beachten Sie, dass die Konfiguration überschrieben wird (z. B. Proxy -Konfiguration), wenn Setoptionen nach dem Kapital festgelegt werden.

Selenium Webdriver Control Flow und Promise Management

selenium webdriver verhält sich ähnlich, weil JavaScript und NodeJs auf dem asynchronen Prinzip basieren. Um Callback -Pyramiden zu vermeiden und die Testingenieure zu testen, die die Skripterfahrung sowie die Lesbarkeit von Code und die Wartbarkeit verbessern, enthält das Selenium WebDriver -Objekt einen Versprechen -Manager mit "ControlFlow". "ControlFlow" ist eine Klasse, die für die Ausführung der asynchronen Webdriver -Befehlsausführung verantwortlich ist.

In der Tat wird jeder Befehl im Treiberobjekt ausgeführt und gibt ein Versprechen zurück. Wenn Sie den analysierten Value -Wert nicht verarbeiten müssen, müssen Sie den nächsten Befehl in "Dann" nicht nisten, wie unten gezeigt:

mocha /path/to/test_suite.js

Tipps für JavaScript -Tests Selenium Webdriver und Mokka

1. Treiber ist ein Webdriver -Objekt, kein Versprechensobjekt
2. driver.gettitle () oder driver.get (URL) oder ein anderer Selenium -Befehl gibt ein Versprechensobjekt zurück!

Dies bedeutet, dass wir Folgendes tun können:

mocha -g “Test-2” /path/to/test_suite.js

1. Da der Treiber selbst asynchron ist, funktionieren die folgenden Operationen nicht:

mocha --recursive -g “Test-2” /directory/

Hinweis: Der Titel ist ein Versprechensobjekt, nicht der tatsächliche analysierte Wert.

mochajs selenium webdriver

im Allgemeinen kann Selenium Webdriver in Mochajs integriert werden, da es für ein normales NodeJS -Skript verwendet wird. Da Mokka jedoch nicht weiß, wann die asynchrone Funktion vor dem Aufrufen von Date () oder einem Versprechen ausgeführt wird, müssen wir sie sehr sorgfältig bewältigen.

Versprechenbasierte

Der Befehl selenium wird automatisch registriert, um sicherzustellen, dass der Befehl webdriver in der richtigen Reihenfolge ausgeführt wird und ein Versprechen zurückgeben sollte.

Der folgende Code zeigt den (vor, vor, nach der Nachreich) oder den Testfall -Körper -Haken.

mocha --help

Das Folgende wird durchgeführt:

1. Laden der Browser -Seite von "my_service"
2. Suchen Sie das Textfeld mit ID "Benutzername"
3. Ausfüllen von Textfeldern mit ID "Benutzername" mit "my_username"
4. Suchen Sie den Seitentitel und überprüfen Sie, ob er gleich "my_title"
ist
5. Webdriver Exit und das Browserfenster schließen. Der Browser -Prozess endet.

Selenium Webdriver Support für Mochajs

Um JavaScript -Tests mit Selenium WebDriver und Mokka auf einfache Weise durchzuführen, fördert Webdriver die Verwendung von Mochajs, indem Mochajs -Testfunktionen (vor, vor, vor, IT usw.) mit Testobjekten eingewickelt werden. Dies schafft einen Umfang, der das Bewusstsein für die Verwendung von Webdriver schärft. Daher besteht keine Notwendigkeit, ein Versprechen zurückzugeben.

Erstens sollte das entsprechende Modul geladen werden:

<code>npm install -g mocha</code>

Alle Mokka -Funktionen beginnen mit "Test"

<code>npm install --save chai</code>

und so weiter. Dann wird der obige Code vollständig umgeschrieben wie:

describe("Inner Suite 1", function(){

    before(function(){

        // 在测试套件执行之前执行某些操作
        // 无论是否有失败的用例

    });

    after(function(){

        // 测试套件执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    beforeEach(function(){

        // 在测试用例执行之前执行某些操作
        // 无论是否有失败的用例

    });

    afterEach(function(){

        // 测试用例执行完成后执行某些操作
        // 无论是否有失败的用例

    });

    it("Test-1", function(){

        // 测试代码
        // 断言

    });

    it("Test-2", function(){

        // 测试代码
        // 断言

    });

    it("Test-3", function(){

        // 测试代码
        // 断言

    });

});

Schlussfolgerung

In diesem Tutorial haben wir die Möglichkeit, JavaScript -Tests mit Selenium WebDriver und Mochajs zu erleben. Wir sollten uns daran erinnern, dass es aufgrund der asynchronen Natur von Nodejs, Mochajs und Selenium Webdriver im Vergleich zu anderen Programmiersprachenbindungen erhebliche Unterschiede gibt.

Solange wir das Versprechen in jeder Funktion, die das Versprechen erstellt (benutzerdefinierte Testbibliotheksfunktionen oder Mochajs -Hooks/Testfälle), weiterhin zurückgeben, führt Mokka sie in der richtigen Reihenfolge aus.

Andere Frameworks wie Webdriverio, Prospractor und CodesptJs bieten Wrapper -Lösungen, mit denen einige Konfigurationen für Benutzer ausgeblendet werden und eine verbesserte Versprechungsverarbeitung für ein besseres Skripterlebnis bieten können. Viele Testautomatisierungsexperten können dies möglicherweise nützlich empfanden.

FAQs (FAQs) zum Testen von JavaScript mit Selenium Webdriver und Mokka

Wie richte ich Selenium Webdriver für JavaScript -Tests ein?

Selenium WebDriver für JavaScript -Tests einrichten. Enthält mehrere Schritte. Zuerst müssen Sie Node.js und NPM (Node Package Manager) in Ihrem System installieren. Nach Abschluss der Installation können Sie NPM verwenden, um Selenium WebDriver zu installieren, indem Sie den Befehl npm installieren selenium-webdriver ausführen. Sie müssen auch einen Browser -Treiber wie Chromedriver für Google Chrome installieren, der durch Ausführen von NPM -Installation von Chromedriver erfolgen kann. Sobald diese Installationen abgeschlossen sind, können Sie mit Selenium WebDriver Testskripte in JavaScript in JavaScript schreiben.

Was ist Mocha und warum verwenden Sie es mit Selenium Webdriver?

Mocha ist ein beliebtes JavaScript -Test -Framework, das eine einfache und flexible Möglichkeit bietet, Testfälle zu schreiben und zu organisieren. Es wird häufig mit Selenium Webdriver verwendet, da es Funktionen wie asynchrone Tests bietet, die für den Umgang verzögerter Vorgänge wie Netzwerkanforderungen und Browseroperationen von entscheidender Bedeutung sind. Mokka bietet auch kurze und klare Syntax, um Ihre Testfälle zu erleichtern, um zu schreiben und zu verstehen.

Wie schreibe ich grundlegende Testfälle mit Selenium WebDriver und Mokka?

Grundlegende Testfälle mit Selenium WebDriver und Mokka umfassen das Erstellen einer neuen JavaScript -Datei und das Schreiben von Testfällen in Mokka und es blockieren. In diesem Block können Sie die API von Selenium WebDriver verwenden, um mit dem Browser zu interagieren, z. Hier ist ein grundlegendes Beispiel:

<code>npm install -g mocha</code>

Wie kann ich in meinen Testfällen mit asynchronen Operationen umgehen?

Sie können JavaScripts Async/Aused Syntax verwenden, um asynchronen Operationen in Testfällen zu verarbeiten. Auf diese Weise können Sie synchrones asynchrone Code schreiben, was das Lesen und Verständnis erleichtert. Im Zusammenhang mit Selenium Webdriver sind Vorgänge wie das Navigieren zu einer Webseite, die Interaktion mit Elementen und die Wartebedingungen asynchron und können mit Async/Wartedieren verarbeitet werden.

Wie führe ich meine Testfälle mit Mokka aus?

Um Testfälle mit Mokka auszuführen, können Sie den Befehl mocha verwenden, gefolgt vom Pfad zur Testdatei. Wenn Ihre Testdatei beispielsweise test.js heißt, können Sie sie mit dem Befehl Mokka test.js ausführen. Mokka findet und führt automatisch alle Testfälle in dieser Datei aus und führt sie aus.

Wie kann ich in meinem Testfall Behauptungen verwenden?

Behauptungen in Testfällen können verwendet werden, um zu überprüfen, ob bestimmte Bedingungen erfüllt sind. Sie möchten beispielsweise behaupten, dass der Titel der Webseite nach der Durchführung einer Suche auf Ihre Erwartungen entspricht. Behauptungen können mit dem integrierten Assert-Modul von JavaScript oder Drittanbietern wie Chai geschrieben werden.

Wie kann ich in meinen Testfällen Fehler umgehen?

Die JavaScript -Try/Catch -Syntax kann verwendet werden, um Fehler in Testfällen zu verarbeiten. Auf diese Weise können Sie alle Fehler erfassen, die während der Ausführung von Testfall auftreten und sie angemessen behandeln, beispielsweise durch Protokollierung von Fehlern und Fehlschlägen des Testfalls.

Wie kann man mit Elementen auf einer Webseite interagieren?

Sie können die API von Selenium WebDriver verwenden, um mit Elementen auf einer Webseite zu interagieren. Dies beinhaltet das Klicken auf ein Element, das Eingeben im Eingangsfeld und das Lesen von Elementeigenschaften. Diese Vorgänge werden mit der Methode für die Findelement -Methode von Triver durchgeführt, die ein Webelement -Objekt zurückgibt, mit dem Sie interagieren können.

Wie kann man in meinem Testfall auf die Bedingungen warten?

Sie können in meinem Testfall mit dem Treiber von Selenium WebDriver auf die Bedingungen warten. Diese Methode nimmt eine bedingte und optionale Zeitüberschreitung an und wartet, bis der Zustand erfüllt ist oder das Timeout erreicht ist. Sie können das bis zum Erstellen einer Bedingung mit dem Modul verwenden, z.

Wie führe ich meine Testfälle in verschiedenen Browsern aus?

Sie können Testfälle in verschiedenen Browsern ausführen, indem Sie den Browser beim Erstellen einer Webdriver -Instanz angeben. Beispielsweise können Sie Testfälle in Firefox mit New Builder (). Forbrowser ('Firefox') ausführen oder sie mit New Builder (). Forbrowser ('Chrome') in Chrome ausführen. Sie müssen den entsprechenden Browser -Treiber installieren, damit es funktioniert.

Das obige ist der detaillierte Inhalt vonSo testen Sie Ihr JavaScript mit Selenium WebDriver und Mokka. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!