Show Menu
ARGOMENTI×

Verifica automatica dei moduli adattivi

Panoramica

I moduli adattivi sono parte integrante delle interazioni con i clienti. È importante verificare i moduli adattivi con tutte le modifiche apportate, ad esempio durante l'implementazione 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 al loro interno può risultare noiosa.
Calvin consente di automatizzare il 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.
Con Calvin è possibile creare test case in CRXDE ed eseguire test dell'interfaccia utente direttamente nel browser Web per verificare accuratamente i seguenti aspetti dei moduli adattivi:
Aspetto modulo adattivo per il test Descrizione
Esperienza di precompilazione di un modulo adattivo
  • Il modulo viene precompilato come previsto in base al tipo di modello dati?
  • I valori predefiniti degli oggetti modulo vengono precompilati come previsto?
Invio dell'esperienza di un modulo adattivo
  • I dati corretti vengono generati durante l'invio?
  • Il modulo viene convalidato nuovamente sul server durante l'invio?
  • L'azione di invio è configurata per l'esecuzione del modulo?
Regole di espressione
  • Le espressioni associate agli oggetti modulo, come calculate, visibili, eseguono script dopo l'uscita da un campo, durante l'esecuzione delle relative operazioni dell'interfaccia utente?
Convalide
  • Le convalide dei campi vengono eseguite come previsto dopo l'esecuzione delle operazioni?
Caricamento Lazy
  • Quando si fa clic sulle schede (o su qualsiasi elemento di navigazione di un pannello), il codice HTML che viene recuperato dal server viene recuperato in base alla configurazione di caricamento pigro?
Interazione interfaccia

Prerequisiti

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

Esempio: Creare 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 i passaggi descritti di seguito e modificando il codice JavaScript al punto 11, è possibile creare una suite di test personalizzata per verificare i moduli adattivi.
  1. Passare a CRXDE Lite nel browser Web: https://[server]:[port]/crx/de .
  2. Fare clic con il pulsante destro del mouse sulla sottocartella /etc/clientlibs e scegliere Crea > Crea nodo . Immettete un nome (qui afTestRegistration), specificate il tipo di nodo come cq:ClientLibraryFolder e fate clic su OK .
    La cartella clientlibs contiene l’aspetto di registrazione dell’applicazione (JS e Init). Si consiglia di registrare tutti gli oggetti delle suite di test di Hobbes specifici per un modulo nella cartella clientlibs.
  3. Specificate i seguenti valori di proprietà nel nodo appena creato (qui afTestRegistration), quindi fate clic su Salva tutto . Queste proprietà consentono a Hobbes di riconoscere la cartella come un test. Per riutilizzare la libreria client come dipendenza in altre librerie client, denominatela granite.testing.calvin.test.
Proprietà Tipo Valore
categorie
Stringa[]
granite.testing.hobbes.test, granite.testing.calvin.test
dipendenze
Stringa[]
granite.testing.hobbes.testrunner, granite.testing.calvin, apps.testframework.all
La clientlib granite.testing.calvin.af contiene tutte le API dei moduli adattivi. Queste API fanno parte dello spazio dei nomi di calvin.
  1. Fare clic con il pulsante destro del mouse sul nodo test (qui afTestRegistration) , quindi scegliere Crea > Crea file . Denominate il file js.txt e fate clic su OK .
  2. Nel file js.txt aggiungete il testo seguente:
    #base=.
    js.txt
    
    
  3. Fate clic su Salva tutto , quindi chiudete il file js.txt.
  4. Fare clic con il pulsante destro del mouse sul nodo test (qui afTestRegistration) e scegliere Crea > Crea file . Denominate il file init.js e fate clic su OK .
  5. Copiate il codice seguente nel file init.js e fate 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, modificate di conseguenza il nome.
  6. Fare clic su Crea > Crea nodo per creare un nodo sotto la cartella clientlib per ciascun modulo da verificare. In questo esempio viene utilizzato un nodo denominato testForm per testare un modulo adattivo denominato testForm . Specificare le proprietà seguenti e fare clic su OK :
    • Nome: testForm (nome del modulo)
    • Tipo: cq:ClientLibraryFolder
  7. Aggiungete le seguenti proprietà al nodo appena creato (qui testForm) per verificare un modulo adattivo:
    Proprietà
    Tipo
    Valore
    categorie
    Stringa #
    granite.testing.hobbes.test, granite.testing.hobbes.test.testForm
    dipendenze
    Stringa #
    granite.testing.calvin.test
    In questo esempio viene utilizzata una dipendenza da client lib granite.testing.calvin.test per una migliore gestione. In questo esempio viene aggiunta anche una categoria client lib, "granite.testing.hobbes.test.testForm", per riutilizzare, se necessario, questa versione client.
  8. Fare clic con il pulsante destro del mouse sulla cartella creata per il modulo di prova (qui testForm) e selezionare Crea > Crea file . Denominate il file scriptingTest.js e aggiungete il codice seguente al file, quindi fate clic su Salva tutto.
    Per utilizzare il codice seguente per testare un altro modulo adattivo, modificare il percorso e il nome del modulo in navigateTo (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. Per testare i moduli adattivi tramite Hobbes, eseguite il test case. Per i passaggi per l'esecuzione dei test case, consultate Esecuzione di test nell'interfaccia utente tramite test automatici.
Potete anche installare il pacchetto nel file allegato SampleTestPackage.zip per ottenere gli stessi risultati dei passaggi descritti in Esempio: Creare una suite di test per un modulo adattivo utilizzando Hobbes come framework di test.

Test dell’interfaccia utente mediante test automatici

Esecuzione di una singola suite di test

Le suite di test possono essere eseguite singolarmente. Quando eseguite 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, fate clic o toccate il 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. Esaminate i risultati del test case toccando o facendo clic sulla descrizione per aprire il pannello Risultati. Toccando o facendo clic sul nome del test case nel pannello Risultati vengono visualizzati tutti i dettagli.
La verifica dei moduli adattivi AEM è simile alla verifica dell’interfaccia utente di AEM. Per ulteriori informazioni sulla verifica dei moduli adattivi, vedere i seguenti argomenti in Verifica dell’interfaccia :
  • Visualizzazione delle suite di test
  • Esecuzione di più test

Glossario

Term Descrizione
Suite di test
Una suite di test è una raccolta di casi di test correlati.
Caso di prova
Un test case rappresenta un'attività eseguita dall'utente utilizzando l'interfaccia utente. Aggiungete i casi di test alla suite di test per verificare le attività eseguite dagli utenti.
Azioni
Le azioni sono metodi che eseguono un gesto nell'interfaccia utente, ad esempio facendo clic su un pulsante o riempiendo una casella di input con un valore.
I metodi delle classi hobs.actions.Asserts, hobs.actions.Core e hobs.utils.af sono azioni utilizzabili nei test. Tutte le azioni vengono eseguite in modo sincrono.
Ambiente di authoring o pubblicazione
In generale, i moduli possono essere sottoposti a test in ambiente di creazione e pubblicazione. In caso di ambiente di pubblicazione, per impostazione predefinita, l'accesso per eseguire il test è limitato. Questo perché tutte le librerie client correlate al runtime di test si trovano all'interno della struttura /libs nella struttura JCR.