Sie sehen sich Hilfeinhalte der folgenden Version an:

Übersicht

Adaptive Formulare sind für Ihre Kunden von wesentlicher Bedeutung.Es ist wichtig, Ihre adaptiven Formulare bei jeder Änderung, die Sie an ihnen vornehmen, zu testen, z. B. beim Verwenden eines neuen Pakets oder beim Ändern einer Regel im Formular. Allerdings kann das funktionelle Testen adaptiver Formen und jedes Feld in ihnen mühsam sein. 

Calvin ermöglicht es Ihnen das automatische Testen der adaptiven Formulare im Webbrowser. Calvin verwendet die Benutzeroberfläche von Hobbess für das Erstellen von Tests und bietet die folgenden Werkzeuge:

  • Ein JavaScript-API für die Erstellung von Tests.
  • Eine Benutzeroberfläche für das Ausführen von Tests.

Mit Calvin können Sie Testfälle in CRXDE erstellen und UI-Tests direkt im Webbrowser ausführen, um Ihre adaptiven Formulare gründlich zu testen.

Zu testende adaptiver Formularaspekte Beschreibung
Befüllen eines adaptiven Formulars
  • Wird das Formular erwartungsgemäß auf der Grundlage des Datenmodells befüllt?
  • Werden die Vorschlagswerte von Formularobjekten erwartungsgemäß befüllt?
Senden Sie eines adaptiven Formulars
  • Werden bei der Übermittlung korrekte Daten generiert?
  • Wird das Formular während des Sendens auf dem Server erneut validiert?
  • Ist die Sendeaktion für das ausgeführte Formular konfiguriert?

Ausdrucksregeln

 

  • Werden die mit Formularobjekten verknüpften Ausdrücke, wie z. B. rechnen, sichtbar machen, Skripte ausführen, nachdem ein Feld geschlossen wurde, ausgeführt, nachdem die entsprechenden UI-Vorgänge ausgeführt wurden?
Validierungen
  • Werden Feldvalidierungen nach Durchführung des Vorgang erwartungsgemäß ausgeführt?

Verzögertes Laden

 

  • Wird beim Klicken Sie auf (oder auf ein Navigationselement eines Bereichs) der HTML-Code vom Server abgerufen, wie es in der Konfiguration für das langsame Laden der Dateien vorgesehen ist?

 

UI-Interaktion

 

Voraussetzungen

Bevor Sie diesen Artikel verwenden, um Ihre Testfälle zu erstellen, müssen Sie Folgendes wissen:

Beispiel: Erstellen Sie einen Test für ein adaptives Formular mit Hobbes als Tests-Rahmen

Das folgende Beispiel führt Sie durch die Erstellung eines Testfalls zum Testen mehrerer adaptiver Formulare. Sie müssen einen separaten Testfall für jedes Formular erstellen, das Sie testen wollen. Wenn Sie die folgenden Schritte befolgen und den JavaScript-Code in Schritt 11 ändern, können Sie Ihre eigenen Testfälle erstellen, um Ihre adaptiven Formulare zu testen. 

  1. Navigieren Sie zu CRXDE Lite in Ihrem Webbrowser: http://[Server]:[Port]/crx/de.

  2. Klicken Sie mit der rechten Maustaste auf den Unterordner /etc/clientlibs und dann auf Erstellen > Knoten erstellen. Geben Sie einen Namen (hier afTestRegistration) ein, geben Sie die Art des Knotens als cq:ClientLibraryFolder ein und klicken Sie auf OK.

    Der Ordner „clientlibs“ enthält den Ausrichtungsaspekt Ihrer Anwendung (JS und Init). Es wird empfohlen, dass Sie alle Hobbes Test-Objekte, die für ein Formular spezifisch sind, im Clientlibs-Ordner registrieren.

  3. Geben Sie folgende Werte im neu erstellten Knoten (hier afTestRegistration) ein und klicken Sie auf Alle speichern. Diese Eigenschaften helfen Hobbes dabei, den Ordner als Test zu erkennen. Um diese Client-Bibliothek als Abhängigkeit in anderen Client-Bibliotheken wiederzuverwenden, benennen Sie sie granite.testing.calvin.tests. 

    Eigenschaft Typ Wert

    Kategorien

    Zeichenfolge[]

    granite.testing.hobbes.tests, granite.testing.calvin.tests

    dependencies

    Zeichenfolge[]

    granite.testing.hobbes.testrunner, granite.testing.calvin, apps.testframework.all

    Hinweis:

    Die granite.testing.calvin.af-clientlib enthält alle adaptiven Formular-APIs. Diese APIs sind Teil des Calvin-namespace.

    1_afTestRegistration
  4. Klicken Sie auf den Testknoten (hier afTestRegistration) mit der rechten Maustaste und klicken Sie dann auf Erstellen > Datei erstellen. Benennen Sie die Datei „js.txt“ und klicken Sie auf OK.

  5. In der js.txt-Datei fügen Sie den folgenden Text ein: 

    #base=.
    js.txt
    
  6. Klicken Sie auf Alle speichern und schließen Sie dann die js.txt-Datei.

  7. Klicken Sie auf den Testknoten (hier afTestRegistration) mit der rechten Maustaste und wählen Sie Erstellen > Datei erstellen. Nennen Sie die Datei init.js und klicken Sie auf OK.

  8. Kopieren Sie folgenden Code in die init.js-Datei und klicken Sie auf Alle speichern:

    (function(window, hobs) {
        'use strict';
        window.testsuites = window.testsuites || {};
     	// Registering the test form suite to the sytem
     	// If there are other forms, all registration should be done here
        window.testsuites.testForm = new hobs.TestSuite("Adaptive Form - Demo Test", {
            path: '/etc/clientlibs/afTestRegistration/init.js',
            register: true
        });
    	// window.testsuites.testForm1 = new hobs.TestSuite("testForm1");
    }(window, window.hobs));

    Der obige Code erstellt Testfälle, die Adaptives Formular- Demo Test heißen. Um Testfälle mit einem anderen Namen anzulegen, ändern Sie den Namen entsprechend.

  9. Klicken Sie auf Erstellen > Knoten erstellen, um einen Knoten unter dem clientlib-Ordner für jedes Formular zu erstellen, das Sie testen möchten. Dieses Beispiel verwendet einen Knoten mit dem Namen testForm, um ein adaptives Formular mit dem Namen testForm zu testen. Legen Sie die folgenden Eigenschaften fest und klicken Sie auf OK:

    • Name: testForm (Ihr Formularname)
    • Type: cq:ClientLibraryFolder
  10. Fügen Sie dem neu angelegten Knoten (hier testForm) die folgenden Eigenschaften hinzu, um ein adaptives Formular zu testen:

    Eigenschaft Typ Wert
    Kategorien Zeichenfolge[] granite.testing.hobbes.tests, granite.testing.hobbes.tests.testForm
    dependencies Zeichenfolge[] granite.testing.calvin.tests

    Hinweis:

    Dieses Beispiel verwendet eine Abhängigkeit vom Client-Lib granite.testing.calvin.tests für ein besseres Management. Dieses Beispiel fügt auch eine Client-Lib-Kategorie, „granite.testing.hobbes.tests.testForm“ hinzu, um diese Client-Lib, falls erforderlich, wiederzuverwenden.

    2_testFormProperties
  11. Klicken Sie mit der rechten Maustaste auf den Ordner, den Sie für das Testformular (hier testForm) erstellt haben und wählen Sie Erstellen > Datei erstellen. Nennen Sie die Datei scriptingTest.js und fügen Sie den folgenden Code zur Datei hinzu und klicken Sie auf Alle speichern.

    Um den folgenden Code zum Testen eines anderen adaptiven Formulars zu verwenden, ändern Sie den Pfad und den Namen des Formulars in navigateTo (Zeilen 11, 36 und 62) und die entsprechenden Testfälle. Weitere Informationen zu APIs für die Prüfung verschiedener Aspekte von Formularen und von Formularobjekten finden Sie unter Calvin-APIs

     

    (function(window, hobs) {
        'use strict';
    
    	var ts = new hobs.TestSuite("Script Test", {
            path: '/etc/clientlibs/testForm/scriptingTest.js',
    		register: false
    	})	
    
        .addTestCase(new hobs.TestCase("Checking execution of calculate script")
            // navigate to the testForm which is to be tested
            .navigateTo("/content/forms/af/testForm.html?wcmmode=disabled")
            // check if adaptive form is loaded
            .asserts.isTrue(function () {
                return calvin.isFormLoaded()
            })
            .execSyncFct(function () {
                // create a spy before checking for the expression
                calvin.spyOnExpression("panel1.textbox1");
                // setValue would trigger enter, set the value and exit from the field
                calvin.setValueInDOM("panel1.textbox", "5");
            })
            // if the calculate expression was setting "textbox1" value to "5", let's also check that
            .asserts.isTrue(function () {
                return calvin.isExpressionExecuted("panel1.textbox1", "Calculate");
            })
            .execSyncFct(function () {
                calvin.destroySpyOnExpression("panel1.textbox1");
            })
            .asserts.isTrue(function () {
                return calvin.model("panel1.textbox1").value == "5"
            })
        )
    
        .addTestCase(new hobs.TestCase("Calculate script Test")
            // navigate to the testForm which is to be tested
            .navigateTo("/content/forms/af/cal/demoform.html?wcmmode=disabled&dataRef=crx:///content/forms/af/cal/prefill.xml")
            // check if adaptive form is loaded
            .asserts.isTrue(function () {
                return calvin.isFormLoaded()
            })
    
            .execSyncFct(function () {
                // create a spy before checking for the expression
                calvin.spyOnExpression("panel2.panel1488218690733.downPayment");
                // setValue would trigger enter, set the value and exit from the field
                calvin.setValueInDOM("panel2.panel1488218690733.priceProperty", "1000000");
            })
            .asserts.isTrue(function () {
                return calvin.isExpressionExecuted("panel2.panel1488218690733.downPayment", "Calculate");
            })
            .execSyncFct(function () {
                calvin.destroySpyOnExpression("panel2.panel1488218690733.downPayment");
            })
            .asserts.isTrue(function () {
                // if the calculate expression was setting "downPayment" value to "10000", let's also check that
    			return calvin.model("panel2.panel1488218690733.downPayment").value == 10000
            })
        )
    
        .addTestCase(new hobs.TestCase("Checking execution of Value commit script")
            // navigate to the testForm which is to be tested
            .navigateTo("/content/forms/af/cal/demoform.html?wcmmode=disabled&dataRef=crx:///content/forms/af/cal/prefill.xml")
            // check if adaptive form is loaded
            .asserts.isTrue(function () {
                return calvin.isFormLoaded()
            })
    
            .execSyncFct(function () {
                // create a spy before checking for the expression
                calvin.spyOnExpression("panel2.panel1488218690733.priceProperty");
                // setValue would trigger enter, set the value and exit from the field
                calvin.setValueInDOM("panel2.panel1488218690733.priceProperty", "100");
            })
            .asserts.isTrue(function () {
                return calvin.isExpressionExecuted("panel2.panel1488218690733.priceProperty", "Value Commit");
            })
            .execSyncFct(function () {
                calvin.destroySpyOnExpression("panel2.panel1488218690733.priceProperty");
            })
            .asserts.isTrue(function () {
    	        // if the value commit expression was setting "textbox1488215618594" value to "0", let's also check that
                return calvin.model("panel2.panel1488218690733.textbox1488215618594").value == 0
            })
        );
    
    	// register the test suite with testForm
     	window.testsuites.testForm.add(ts);
    
    
     }(window, window.hobs));
    

    Der Testfall wird erstellt. Führen Sie den Testfall aus, um adaptive Formulare über Hobbes zu testen. Eine Anleitung zum Ausführen von Testfällen finden Sie unter Ausführen von Tests in wenn Testen Ihrer Benutzeroberfläche mithilfe von automatischen Tests.

Herunterladen

Testen der UI mit automatisierten Tests

Ausführen einer einzelnen Testsuite

Testsuites können einzeln ausgeführt werden. Wenn Sie eine Testsuite ausführen, ändert sich die Seite, wenn die Testfälle und ihre Aktionen ausgeführt werden, und die Ergebnisse werden nach Abschluss des Tests angezeigt. Symbole zeigen die Ergebnisse an.

Ein Häkchen zeigt einen bestandenen Test:

Eine X-Symbol zeigt einen fehlgeschlagenen Test an:  

Ausführen einer Testsuite:

  1. Klicken Sie im Bereich „Tests“ auf den Namen des Testfalls, den Sie ausführen möchten, oder tippen Sie auf den Namen des Testfalls, um die Details der Aktionen anzuzeigen.

    1_TapNameOfTestCase
  2. Klicken oder tippen Sie auf die Schaltfläche „Ausführen“.  

    2_ClickRun
  3. Der Platzhalter wird durch Seiteninhalte ersetzt, wenn der Test ausgeführt wird.

    3_PageContent
  4. Überprüfen Sie die Ergebnisse des Testfalls, indem Sie auf die Beschreibung tippen oder auf die Beschreibung klicken, um das Ergebnisfenster zu öffnen. Durch Tippen oder Klicken auf den Namen Ihres Testfalls im Bedienfeld „Ergebnisse“ werden alle Details angezeigt.

    4_ReviewResults

Die Schritte zum Testen Ihrer adaptiven AEM-Formulare sind ähnlich den Schritten zum Testen Ihrer AEM-Benutzeroberfläche. Weitere Informationen zum Testen der adaptiven Formulare finden Sie unter den folgenden Themen Benutzeroberfläche testen:

  • Testsuits anzeigen
  • Ausführen mehrerer Tests

Glossar

Begriff Beschreibung

Testsuite

Eine Testsuite ist eine Sammlung zusammengehöriger Testfälle.

Testfall

Ein Testfall stellt eine Aufgabe dar, die ein Benutzer mithilfe der Benutzeroberfläche ausführt. Fügen Sie Testfälle zu Ihrer Testsuite hinzu, um die Aktivitäten zu testen, die Benutzer ausführen.

Aktionen

Aktionen sind Methoden, die eine Geste auf der Benutzeroberfläche ausführen, wie z. B. das Klicken auf eine Schaltfläche oder das Füllen eines Eingabefeldes mit einem Wert.

Die Methoden der Klassen hobs.actions.Assets, hobs.actions.Core und hobs.utils.af sind Aktionen, die Sie in Ihren Tests verwenden können. Alle Aktionen werden synchron ausgeführt.

Autoren- oder Veröffentlichungsumgebung

Im Allgemeinen können Formulare entweder im Autoren- oder im Veröffentlichungsumgebung getestet werden. Im Falle der Veröffentlichungsumgebung ist der Zugriff auf die Testausführung standardmäßig eingeschränkt. Dies liegt daran, dass alle Client-Bibliotheken, die mit dem Test-Runner in Verbindung stehen, innerhalb der /libs in der JCR-Struktur liegen.

Dieses Werk unterliegt den Bedingungen der Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.  Twitter™- und Facebook-Beiträge fallen nicht unter die Bedingungen der Creative Commons-Lizenz.

Rechtliche Hinweise   |   Online-Datenschutzrichtlinie