Adaptive Formulare sind für die Interaktion mit Ihren Kunden von wesentlicher Bedeutung. Es ist wichtig, Ihre adaptiven Formulare bei jeder Änderung zu testen, die Sie daran vornehmen, z. B. beim Rollout eines neuen Fixpack 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 nutzt die Benutzeroberfläche von Hobbes zum Ausführen der Tests und stellt die folgenden Tools bereit:
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 |
|
Senden Sie eines adaptiven Formulars |
|
Ausdrucksregeln
|
|
Validierungen |
|
Verzögertes Laden
|
|
UI-Interaktion |
Bevor Sie diesen Artikel verwenden, um Ihre Testfälle zu erstellen, müssen Sie Folgendes wissen:
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.
Navigieren Sie in Ihrem Webbrowser zur CRXDE Lite: https://'[server]:[port]'/crx/de
.
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.
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 |
categories |
Zeichenfolge[] |
granite.testing.hobbes.tests, granite.testing.calvin.tests |
dependencies |
Zeichenfolge[] |
granite.testing.hobbes.testrunner, granite.testing.calvin, apps.testframework.all |
Die granite.testing.calvin.af-clientlib enthält alle adaptiven Formular-APIs. Diese APIs sind Teil des Calvin-namespace.
Klicken Sie mit der rechten Maustaste auf den Testknoten (hier afTestRegistration) und klicken Sie dann auf Erstellen > Datei erstellen. Nennen Sie die Datei js.txt und klicken Sie auf OK.
In der js.txt-Datei fügen Sie den folgenden Text ein:
#base=.
js.txt
Klicken Sie auf Alle speichern und schließen Sie dann die Datei js.txt.
Klicken Sie mit der rechten Maustaste auf den Testknoten (hier afTestRegistration) und klicken Sie auf Erstellen > Datei erstellen. Nennen Sie die Datei init.js und klicken Sie auf OK.
Kopieren Sie den folgenden Code in die Datei init.js 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.
Klicken Sie auf Erstellen >Knoten erstellen, um einen Knoten unter dem clientlib-Ordner für jedes Formular zu erstellen, das Sie testen möchten. In diesem Beispiel wird ein Knoten mit dem Namen testForm verwendet, um ein adaptives Formular mit dem Namen testForm zu testen. Legen Sie die folgenden Eigenschaften fest und klicken Sie auf OK:
Fügen Sie die folgenden Eigenschaften zum neu erstellten Knoten (hier testForm) hinzu, um ein adaptives Formular zu testen:
Eigenschaft | Typ | Wert |
---|---|---|
categories | Zeichenfolge[] | granite.testing.hobbes.tests, granite.testing.hobbes.tests.testForm |
dependencies | Zeichenfolge[] | granite.testing.calvin.tests |
In diesem Beispiel wird eine Abhängigkeit von der Client-Bibliothek granite.testing.calvin.tests verwendet, um eine bessere Verwaltung zu gewährleisten. Dieses Beispiel fügt auch eine Client-Lib-Kategorie, „granite.testing.hobbes.tests.testForm“ hinzu, um diese Client-Lib, falls erforderlich, wiederzuverwenden.
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 zum Testen verschiedener Aspekte von Formularen und 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. Fahren Sie fort, um den Testfall auszuführen, um adaptive Formulare über Hobbes zu testen. Anweisungen zum Ausführen der Testfälle finden Sie unter Ausführen von Tests unter Testen der Benutzeroberfläche mit automatisierten Tests.
Sie können das Paket auch in der angehängten Datei SampleTestPackage.zip installieren, um dieselben Ergebnisse zu erzielen wie im Beispiel: Erstellen einer Testsuite für ein adaptives Formular mit Hobbes als Testrahmen.
Test-Suites können einzeln ausgeführt werden. Wenn Sie eine Test-Suite ausführen, ändert sich die Seite, während die Testfälle und ihre Aktion ausgeführt werden, und die Ergebnisse werden nach dem Abschluss des Tests angezeigt. Symbole zeigen die Ergebnisse an.
Das Häkchen-Symbol kennzeichnet einen erfolgreichen Test:
Ein X-Symbol weist auf einen fehlgeschlagenen Test hin:
So führen Sie eine Test-Suite aus:
Klicken oder tippen Sie im Testfeld auf den Namen des Testfalls, den Sie ausführen möchten, um die Details zu den Aktionen anzuzeigen.
Klicken oder tippen Sie auf die Schaltfläche Tests ausführen .
Der Platzhalter wird durch Seiteninhalte ersetzt, wenn der Test ausgeführt wird.
Um die Ergebnisse des Testfalls anzuzeigen, tippen oder klicken Sie auf die Beschreibung, um das Feld Ergebnis zu öffnen. Wenn Sie im Feld Ergebnis auf den Namen des Testfalls tippen oder klicken, werden alle Details angezeigt.
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:
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. |