Verifica automatica dei moduli adattivi

Panoramica

I moduli adattivi sono parte integrante delle interazioni dei clienti. È importante testare i moduli adattivi con ogni modifica apportata, ad esempio durante il rollout di un nuovo fix pack o la modifica di una regola nel modulo. Tuttavia, la verifica funzionale dei moduli adattivi e di tutti i campi in essi contenuti può risultare noiosa.

Calvin consente di automatizzare i test dei moduli adattivi nel browser web. Calvin utilizza l'interfaccia utente di Hobbes per eseguire i test e fornisce i seguenti strumenti:

• API JavaScript per la creazione di test.
• Interfaccia utente per l’esecuzione di test.

Utilizzando Calvin, puoi creare casi di test in CRXDE ed eseguire i test dell’interfaccia utente direttamente nel browser web per testare a fondo i seguenti aspetti dei moduli adattivi:

Prerequisiti

Prima di utilizzare questo articolo per creare i casi di test, è necessario conoscere quanto segue:

• Creazione di suite di test ed esecuzione di casi di test utilizzando Hobbes
• API JavaScript di Hobbes
• API JavaScript di Calvin

Esempio: Crea una suite di test per un modulo adattivo utilizzando Hobbes come framework di test

L’esempio seguente illustra la creazione di una suite di test per il test di più moduli adattivi. È necessario creare un test case separato per ciascun modulo da sottoporre a test. Seguendo passaggi simili a quelli seguenti e modificando il codice JavaScript al passaggio 11, puoi creare una tua suite di test per testare i moduli adattivi.

1. Passa a CRXDE Lite nel browser Web: https://[server]:[port]/crx/de.

2. Fai clic con il pulsante destro del mouse sulla sottocartella /etc/clientlibs e fai clic su Crea > Crea nodo. Immetti un nome (qui afTestRegistration), specifica il tipo di nodo come cq:ClientLibraryFolder e fai clic su OK.

   La cartella clientlibs contiene l'aspetto di registrazione dell'applicazione (JS e Init). È consigliabile registrare tutti gli oggetti delle suite di test Hobbes specifici per un modulo nella cartella clientlibs.

3. Specifica i seguenti valori di proprietà nel nodo appena creato (qui afTestRegistration), quindi fai clic su Salva tutto. Queste proprietà consentono ad Hobbes di riconoscere la cartella come un test. Per riutilizzare questa libreria client come dipendenza in altre librerie client, denominala come granite.testing.calvin.test.

1. Fai clic con il pulsante destro del mouse sul nodo del test (qui afTestRegistration), quindi fai clic su Crea > Crea file. Denomina il file js.txt e fai clic su OK.

2. Nel file js.txt, aggiungi il seguente testo:

   #base=.
   js.txt
   

3. Fai clic su Salva tutto, quindi chiudi il file js.txt.

4. Fai clic con il pulsante destro del mouse sul nodo del test (qui afTestRegistration) e fai clic su Crea > Crea file. Denomina il file init.js e fai clic su OK.

5. Copia il seguente codice nel file init.js e fai clic su Salva tutto:

   (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));
   

   Il codice riportato sopra crea una suite di test denominata Modulo adattivo - Test demo. Per creare una suite di test con un nome diverso, modifica il nome di conseguenza.

6. Fai clic su Crea > Crea nodo per creare un nodo sotto la cartella clientlib per ciascun modulo da testare. In questo esempio viene utilizzato un nodo denominato testForm per testare un modulo adattivo denominato testForm .Specifica le seguenti proprietà e fai clic su OK:

   • Nome: testForm (nome del modulo)
   • Tipo: cq:ClientLibraryFolder

7. Aggiungi le seguenti proprietà al nodo appena creato (qui testForm) per testare un modulo adattivo:

   Proprietà	Tipo	Valore
   categorie	Stringa[]	granite.testing.hobbes.test, granite.testing.hobbes.test.test.testForm
   dipendenze	Stringa[]	granite.testing.calvin.tests

   NOTA

   In questo esempio viene utilizzata una dipendenza da client lib granite.testing.calvin.test per una migliore gestione. Questo esempio aggiunge anche una categoria client lib, "granite.testing.hobbes.test.testForm" per riutilizzare questa libreria client, se necessario.

   

8. Fare clic con il pulsante destro del mouse sulla cartella creata per il modulo di test (qui testForm) e selezionare Crea > Crea file. Denomina il file scriptingTest.js e aggiungi il seguente codice al file, quindi fai clic su Salva tutto.

   Per utilizzare il codice seguente per testare un altro modulo adattivo, modifica il percorso e il nome del modulo in navigaA (righe 11, 36 e 62) e i rispettivi casi di test. Per ulteriori informazioni sulle API per il test di diversi aspetti dei moduli e degli oggetti modulo, vedere API Calvin.

   (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));
   

   Viene creato il test case. Procedi con l’esecuzione del test case per testare i moduli adattivi tramite Hobbes. Per i passaggi per l’esecuzione dei casi di test, consulta Esecuzione di test in Test della propria interfaccia utente tramite l’uso di test automatici.

Puoi anche installare il pacchetto nel file allegato SampleTestPackage.zip per ottenere gli stessi risultati dei passaggi descritti in Esempio: Crea una suite di test per un modulo adattivo utilizzando Hobbes come framework di test.

Ottieni file

Test della vostra interfaccia utente tramite l'uso di test automatici

Esecuzione di una suite di test singola

Le suite di test possono essere eseguite singolarmente. Quando esegui una suite di test, la pagina cambia man mano che vengono eseguiti i casi di test e le relative azioni e i risultati vengono visualizzati dopo il completamento del test. Le icone indicano i risultati.

Un’icona a forma di segno di spunta indica un test superato:

Un'icona "X" indica un test non riuscito:

Per eseguire una suite di test:

1. Nel pannello Test , tocca o fai clic sul nome del Test Case da eseguire per espandere i dettagli delle azioni.

   

2. Tocca o fai clic sul pulsante Esegui test .

   

3. Il segnaposto viene sostituito con il contenuto della pagina durante l’esecuzione del test.

   

4. Rivedi i risultati del Test Case toccando o facendo clic sulla descrizione per aprire il pannello Risultato. Per visualizzare tutti i dettagli, tocca o fai clic sul nome del test case nel pannello Risultato .

   

I passaggi per testare i moduli adattivi AEM sono simili ai passaggi per testare l’interfaccia utente AEM. Per ulteriori informazioni sulla verifica dei moduli adattivi, consulta i seguenti argomenti in Verifica dell'interfaccia utente:

• Visualizzazione delle suite di test
• Esecuzione di più test

Glossario

Risorse Business.Adobe.com

Multichannel Communication Ecommerce Integrations Personalized Experiences Embedded Charts Responsive Forms Customer Experience Management