Testar seu site Drupal ficou mais fácil com o Behat (um tutorial abrangente)

Publicados: 2020-09-08

“Não há nada no mundo mais poderoso do que uma boa história”, disse o rei da inteligência e sabedoria, Tyrion Lannister.

O poder das histórias e da boa comunicação possibilita uma entrega de software colaborativa e eficiente. Evoluindo de metodologias ágeis, as tecnologias Behavior Driven Development (BDD) potencializam esse poder ao máximo para automatizar o processo de teste. Behat é uma dessas tecnologias de BDD que permite testes automatizados usando uma “linguagem onipresente”. Vamos aprender mais sobre Behat, Mink, Gherkin e como implementá-lo no Drupal.

behat drupal

O que é Behat?

Behat é uma estrutura PHP de código aberto usada para automatizar os testes, aproveitando o Behavior Driven Development (BDD). Uma abordagem BDD garante a entrega de software de qualidade, concentrando-se na comunicação contínua e histórias de texto simples. Com o BDD, o testador cria casos de teste em linguagem legível. Por causa disso, é fácil colocar toda a equipe na mesma página, pois todos, desde o product owner até o desenvolvedor, podem entender e obter feedback contínuo sobre o cenário atual.

O que é Gherkin?

A linguagem usada pela ferramenta Behat é o Gherkin, que é uma linguagem de negócios legível e de domínio específico. Gherkin também serve como uma documentação viva e relatórios podem ser gerados para documentar cada execução de teste. Essa linguagem simples baseada em espaços em branco usa palavras de linguagem simples como palavras-chave. Indentações (usando espaço / tabulação) e finais de linha definem a estrutura para o caso de teste. Embora escrever e entender a linguagem seja fácil, o resultado final deve se concentrar em permitir uma melhor colaboração, eficiência, automação e rastreabilidade. Os casos de teste devem ser escritos intuitivamente, focar em elementos importantes, evitar a verificação de registros duplicados e usar uma boa gramática.

O que é Mink?

Mink é um controlador de navegador de código aberto que simula um cenário de teste com o aplicativo da web. Depois que os casos de teste são escritos, ele precisa ser executado e emular as ações do usuário. Com o Mink, você pode usar o mesmo cenário de teste e executá-lo em vários emuladores de navegador como Goutte, Selenium, Chrome, Zombie e muito mais. Ao instalar a extensão Behat Drupal, você verá uma dependência do Mink, portanto, certifique-se de instalá-la também.

Instalação e implementação do Behat no Drupal

A maneira oficial de instalar o Behat em seu projeto Drupal é através do Composer. Ele não só pode instalar o Behat para você, mas também poderá atualizá-lo facilmente para a versão mais recente quando uma for lançada.

• Dentro da pasta do projeto, execute o comando:

 $ composer requer behat / behat

• Ou dentro do seu arquivo composer.json, adicione a instrução require

 "requer": {
                "behat / behat": "^ 3.0.0",
     “Phpunit / phpunit”: “^ 5.0.0”
     }

• Em seguida, execute o comando composer install no terminal.
• Quando estiver pronto, você também notará um novo diretório bin / com um arquivo Behat nele. Este é o executável do Behat e você o usará para executar seus testes e obter informações de depuração.
• Em seguida, crie um arquivo chamado behat.yml dentro da pasta raiz do projeto. Quando o Behat é executado, ele procura um arquivo behat.yml , que ele usa para sua configuração.

padrão:
  suites:
    padrão:
      contextos:
        - Drupal \ DrupalExtension \ Context \ DrupalContext
  extensões:
    Behat \ MinkExtension:
      goutte: ~
      base_url: http://example.org/ # Substitua pelo URL do seu site
    Drupal \ DrupalExtension:
      caixa preta: ~

Para inicializar o projeto, execute o comando:

 vendor / bin / behat –init

Isso cria um recurso / pasta e um arquivo de contexto padrão bootstrap / FeatureContext.php dentro de recursos / pasta.

Escrevendo histórias e executando testes com Behat

Nosso objetivo é descrever as histórias da maneira mais eficaz. As histórias são escritas em uma linguagem legível, Gherkin, com a extensão. recurso no diretório features /.

Vamos imaginar que você precise testar se pode ou não adicionar conteúdo ao tipo de conteúdo de página Básico em seu site. Para isso, você deve ter acesso à página para preencher os campos e salvá-la como administrador.

Então, vamos escrever nossa primeira história:

 Recurso: Verifique a página básica CT
 Para criar uma página
 Como administrador
 Quero acessar / nó / adicionar / página
 Para que eu possa criar uma página

Cenário: Página Básica CT
 Dado que estou conectado como um usuário com a função de "administrador"
 Quando vou para "/ node / add / page"
 E eu insiro "Título da página básica" para "editar título-valor 0"
 Quando eu pressiono "editar-enviar"
 Em seguida, devo ver "Página básica O título da página básica foi criado"

Este arquivo pode ser denominado basic_page.feature . Cada recurso pode ter muitos cenários, que descrevem o comportamento específico do recurso. Cada cenário terá seções:
• Dado - detalha o estado inicial do sistema
• Quando - inclui a ação que o usuário realiza
• Então - descreve o que o usuário vê depois de agir
• E - para manter a conectividade no cenário.
Não há muita diferença entre Then, And e But . Essas palavras são disponibilizadas para tornar seus cenários naturais e legíveis.

Todos os arquivos de recursos podem ser executados pelo fornecedor / bin / behat . Se você deseja executar um arquivo de recurso específico, execute vendor / bin / behat features / basic_page.feature. Também há uma maneira de executar um único cenário apenas adicionando um número de linha onde o cenário é definido: vendor / bin / behat features / basic_page.feature: 11 .

Existem comandos como vendor / bin / behat -dl que fornece a você toda a sintaxe de instrução usada em cenários e vendor / bin / behat -di fornece a sintaxe junto com os exemplos.

Como escrever arquivos de feições

 O Behat executa solicitações curl em URLs em seu site, o que torna o processo de teste bastante rápido, mas também faz o Behat perder a capacidade de testar recursos que exigem Javascript. Portanto, para testar os recursos, só precisamos adicionar a tag @javascript antes de cada cenário que requer Javascript, como este:

Recurso: Verifique a página básica CT
 Para criar uma página
 Como administrador
 Quero acessar / nó / adicionar / página
 Para que eu possa criar uma página

@api @javascript
Cenário: Página Básica CT
 Dado que estou conectado como um usuário com a função de "administrador"
 Quando vou para "/ node / add / page"
E eu insiro "Título da página básica" para "editar título-valor 0"
E eu preencho wysiwyg no campo "edit-body-0-value" com "Basic page content"
Quando eu pressiono "editar-enviar"
 Em seguida , devo ver "Página básica O título da página básica foi criado"


Para testar isso, execute vendor / bin / behat . Isso mostrará as etapas indefinidas nos cenários porque os cenários devem ser mapeados para uma função.

behat


Você pode copiar e colar o trecho de código no arquivo de contexto FeatureContext.php ou executar vendor / bin / behat --dry-run --append-snippets .

Em seguida, você pode escrever as definições para as funções em FeatureContext.php conforme mostrado:

 <? php

use Behat \ Mink \ Exception \ ExpectationException;
use Drupal \ DrupalExtension \ Context \ RawDrupalContext;

/ **
 * Define os recursos do aplicativo a partir do contexto específico.
 * /
class FeatureContext estende RawDrupalContext {

  / **
   * O contexto do vison.
   *
   * @var Drupal \ DrupalExtension \ Context \ MinkContext
   * /
  protegido $ minkContext;

  / **
   * Inicializa o contexto.
   *
   * Cada cenário obtém sua própria instância de contexto.
   * Você também pode passar argumentos arbitrários para o
   * construtor de contexto por meio de behat.yml.
   * /
  public function __construct () {
  }

  / **
   * Preencha wysiwyg no campo.
   *
   * @Então eu preencho wysiwyg no campo: localizador com: valor
   * /
  public function iFillInWysiwygOnFieldWith ($ locator, $ value) {
    $ el = $ this-> getSession () -> getPage () -> findField ($ locator);
    if (vazio ($ el)) {
      lance new ExpectationException ('Não foi possível encontrar WYSIWYG com localizador:'. $ locator, $ this-> getSession ());
    }
    $ fieldId = $ el-> getAttribute ('id');
    if (vazio ($ fieldId)) {
      throw new Exception ('Não foi possível encontrar um id para o campo com localizador:'. $ locator);
    }
    $ this-> getSession ()
      -> executeScript ("CKEDITOR.instances [\" $ fieldId \ "]. setData (\" $ value \ ");");
  }

}

Agora, execute o comando vendor / bin / behat e todos os cenários escritos devem passar. A função JS definida mapeará a declaração do cenário “ E eu preencho wysiwyg on-field" edit-body-0-value " com" Basic page content ".