Automatizar o teste de formulários adaptáveis

Visão geral

Os formulários adaptáveis são parte integrante das interações do cliente. É importante testar seus formulários adaptáveis com todas as alterações feitas neles, por exemplo, ao rolar um novo pacote de correções ou alterar uma regra no formulário. Entretanto, o teste funcional de formulários adaptáveis e cada campo neles pode ser entediante.

O Calvin permite automatizar o teste de seus formulários adaptáveis no navegador da Web. Calvin usa HobbesA interface do usuário do para executar os testes e fornece as seguintes ferramentas:

• Uma API JavaScript para criar testes.
• Uma interface de usuário para executar testes.

Usando o Calvin, você pode criar casos de teste no CRXDE e executar testes da interface diretamente no navegador da Web para testar detalhadamente os seguintes aspectos dos formulários adaptáveis:

Pré-requisitos

Antes de usar este artigo para criar seus casos de teste, você precisa saber o seguinte:

• Criar conjuntos de testes e executar casos de teste usando Hobbes
• APIs JavaScript do Hobbes
• APIs do JavaScript do Calvin

Exemplo: Criar um conjunto de testes para um formulário adaptável usando Hobbes como estrutura de teste

O exemplo a seguir mostra a criação de um conjunto de testes para testar vários formulários adaptáveis. É necessário criar um caso de teste separado para cada formulário que deve ser testado. Ao seguir etapas semelhantes às seguintes e modificar o código JavaScript na etapa 11, você pode criar seu próprio conjunto de testes para testar seus formulários adaptáveis.

1. Vá para o CRXDE Lite no navegador da Web: https://[server]:[port]/crx/de.

2. Clique com o botão direito do mouse na subpasta /etc/clientlibs e clique em Criar > Criar nó. Insira um nome (aqui afTestRegistration), especifique o tipo de nó como cq:ClientLibraryFolder e clique em OK.

   A pasta clientlibs contém o aspecto de registro do seu aplicativo (JS e Init). É recomendável registrar todos os objetos dos conjuntos de teste Hobbes específicos a um formulário na pasta clientlibs.

3. Especifique os seguintes valores de propriedade no nó recém-criado (aqui afTestRegistration) e clique em Salvar tudo. Essas propriedades ajudam o Hobbes a reconhecer a pasta como um teste. Para reutilizar essa biblioteca do cliente como uma dependência em outras bibliotecas do cliente, nomeie-a como granite.testing.calvin.tests.

1. Clique com o botão direito do mouse no nó de teste (aqui afTestRegistration) e, em seguida, clique em Criar > Criar arquivo. Nomeie o arquivo js.txt e clique em OK.

2. No arquivo js.txt, adicione o seguinte texto:

   #base=.
   js.txt
   

3. Clique em Salvar tudo e então feche o arquivo js.txt.

4. Clique com o botão direito do mouse no nó de teste (aqui afTestRegistration) e clique em Criar > Criar arquivo. Dê um nome ao arquivo init.js e clique em OK.

5. Copie o código a seguir para o arquivo init.js e clique em Salvar tudo:

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

   O código acima cria um conjunto de testes chamado Formulário adaptável - Teste de demonstração. Para criar um conjunto de teste com um nome diferente, altere o nome de acordo.

6. Clique em Criar > Criar nó para criar um nó na pasta clientlib para cada formulário que deseja testar. Esse exemplo usa um nó chamado testForm para testar um formulário adaptável chamado testForm .Especifique as seguintes propriedades e clique em OK:

   • Nome: testForm (nome do formulário)
   • Tipo: cq:ClientLibraryFolder

7. Adicione as seguintes propriedades ao nó recém-criado (aqui testForm) para testar um formulário adaptável:

   Propriedade	Tipo	Valor
   categorias	String[]	granite.testing.hobbes.tests, granite.testing.hobbes.tests.testForm
   dependências	String[]	granite.testing.calvin.tests

   OBSERVAÇÃO

   Este exemplo usa uma dependência na biblioteca cliente granite.testing.calvin.tests para obter um melhor gerenciamento. Este exemplo também adiciona uma categoria de biblioteca do cliente, "granite.testing.hobbes.tests.testForm" para reutilizar esta biblioteca do cliente, se necessário.

   

8. Clique com o botão direito do mouse na pasta que você criou para o formulário de teste (aqui testForm) e selecione Criar > Criar arquivo. Nomeie o arquivo scriptingTest.js, adicione o seguinte código ao arquivo e clique em Salvar tudo.

   Para usar o seguinte código para testar outro formulário adaptável, altere o caminho e o nome do formulário em navigateTo (linhas 11, 36 e 62) e os respectivos casos de teste. Para obter mais informações sobre APIs para testar diferentes aspectos de formulários e objetos de formulário, consulte APIs do 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));
   

   O caso de teste é criado. Continue a executar o caso de teste para testar formulários adaptáveis por meio de Hobbes. Para obter as etapas para executar os casos de teste, consulte Execução de testes em Testes da interface do usuário com testes automatizados.

Você também pode instalar o pacote no arquivo anexado SampleTestPackage.zip para obter os mesmos resultados das etapas explicadas em Exemplo: Crie um conjunto de testes para um formulário adaptável usando Hobbes como estrutura de teste.

Obter arquivo

Testes da interface de usuário com testes automatizados

Executando um único conjunto de testes

Conjuntos de testes podem ser executados individualmente. Quando você executa um Test Suite, a página é alterada à medida que os Casos de teste e suas Ações são executados e os resultados são exibidos após a conclusão do teste. Os ícones indicam os resultados.

Um ícone de marca de verificação indica um teste aprovado:

Um ícone "X" indica um teste com falha:

Para executar um Test Suite:

1. No painel Testes, clique ou toque no nome do caso de teste que deseja executar para expandir os detalhes das ações.

   

2. Clique ou toque no botão Executar testes .

   

3. O espaço reservado é substituído pelo conteúdo da página, conforme o teste é executado.

   

4. Revise os resultados do caso de teste tocando ou clicando na descrição para abrir o painel Resultado. Tocar ou clicar no nome do Caso de teste no painel Resultado mostra todos os detalhes.

   

As etapas para testar seus formulários adaptáveis de AEM são semelhantes às etapas para testar sua interface AEM. Para obter mais informações sobre como testar seus formulários adaptáveis, consulte os seguintes tópicos em Testar sua interface do usuário:

• Visualização de conjuntos de testes
• Execução de vários testes

Glossário

Recursos do Business.Adobe.com

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