Menu

Tutorial do Spock: Testando com Spock e Groovy

spock tutorial testing with spock

Experimente Nosso Instrumento Para Eliminar Problemas

Série de tutoriais práticos de Spock: Testando com a estrutura Spock e linguagem de programação Groovy

Esta série de tutoriais enriqueceria completamente o seu conhecimento no Spock Framework.

Exemplos simples e claros foram incluídos em cada tutorial para sua fácil compreensão do conceito.

Prepare-se para aprender Spock de graça !!

Spock And Groovy

Lista de todos os tutoriais do Spock nesta série:

Aprenda Spock em detalhes com a ajuda desta série de Treinamento Intensivo de Spock para iniciantes e profissionais experientes.

Tutorial #Ligação
Tutorial # 1 Introdução a Spock e Groovy
Tutorial # 2 Escrevendo testes de unidade com Spock
Tutorial # 3 Testes Parametrizados com Spock
Tutorial # 4 Spock Zombando e Stubbing
Tutorial # 5 Spock com teste funcional de selênio
Tutorial # 6 Perguntas da entrevista de Spock

Visão geral dos tutoriais da série Spock

Tutorial_NumO que você aprenderá
Tutorial # 1 Introdução a Spock e Groovy

Este tutorial introdutório explicará tudo sobre Spock, que é uma estrutura de teste construída sobre o Groovy. Ele reforça o BDD no núcleo e garante que todos os testes escritos usando a estrutura sigam as convenções do BDD.
Tutorial # 2 Escrevendo testes de unidade com Spock

Neste tutorial, vamos percorrer todos os detalhes / etapas necessários para iniciar o teste de unidade em Spock, juntamente com exemplos simples.
Tutorial # 3 Testes Parametrizados com Spock

Este tutorial explicará claramente o que são testes parametrizados e como você pode aproveitar os recursos integrados do Spock para realizar testes orientados por dados.
Tutorial # 4 Spock Zombando e Stubbing

Este tutorial de Spock explicará em detalhes sobre Mocking e Stubbing, que são um dos blocos de construção mais essenciais de testes de unidade extensivos.
Tutorial # 5 Spock com teste funcional de selênio

Aprenda como usar o Spock para testes de integração (como serviços de descanso) e para testes funcionais a partir deste tutorial informativo. Por exemplo, integrando Spock com selênio.
Tutorial # 6 Perguntas da entrevista de Spock

Este tutorial inclui uma lista das perguntas mais populares da entrevista de Spock com respostas e exemplos. Essas perguntas realmente orientariam qualquer um a passar com sucesso a entrevista de Spock na primeira tentativa.

O que você aprenderá:

O que é Spock?

Spock é uma estrutura de teste desenvolvida com base no Groovy. Ele reforça o BDD no núcleo e garante que todos os testes escritos usando a estrutura sigam as convenções do BDD.

Além disso, ao contrário do JUnit, Spock tem suas próprias bibliotecas duplas de simulação e teste, bem como suporte total para cenários de teste parametrizados.

É devido a este pacote completo em si mesmo, as especificações de Spock são super legíveis e expressivas e como resultado eles fazem o teste para atingir cada vez mais o que se pretendia para reduzir o código clichê clichê.

Apesar de todos esses recursos interessantes, os testes Spock podem ser executados usando o executor de teste JUnit existente e as ferramentas de linha de comando / compilação existentes, como Maven e Gradle, o que o torna ainda mais atraente de usar. Em poucas palavras, Spock combina todos os bons recursos do JUnit, BDD (frameworks como JBehave & Pepino ), bem como zombaria.

Vamos dar uma olhada em alguns exemplos que ilustram cada um desses recursos nas próximas seções.

Assista ao tutorial em vídeo Spock e Groovy

O que é Groovy?

Groovy é uma linguagem de script para a plataforma Java.

Algumas das principais características do groovy incluem:

# 1) Ele pode ser usado como tipado dinamicamente (onde uma variável pode conter qualquer tipo de dados), bem como tipado estaticamente (o que impõe construções fortemente tipadas em variáveis ​​que contêm dados).

Exemplo : Atribuímos array e map da mesma maneira e internamente o groovy determina o tipo e o manipula apropriadamente.

def listType = (1,2,3) def mapType = ('red':2,'green':3) println(listType.getClass()) println(mapType.getClass())

A saída do exemplo de código acima é:

aula java.util.ArrayList
aula java.util.LinkedHashMap

#dois) Todo código Java válido também é um código Groovy válido (mas não o contrário, pois também possui recursos adicionais).

# 3) Outros recursos incluem metaprogramação, encerramentos, verificação de tipo estático, etc.

# 4) diferente Java ponto-e-vírgulas são opcionais no groovy e os tipos primitivos são considerados objetos por padrão.

Como esta série de tutoriais é mais focada em Spock, aprenderemos apenas os recursos do Groovy que são essenciais para a criação de especificações de teste baseadas em Spock.

Introdução ao Spock

Para começar, vamos ver quais bibliotecas são necessárias, dependendo do sistema de compilação que você está usando (por exemplo, Gradle / maven).

Para projetos baseados em Maven

Os projetos Maven precisarão incluir um plug-in para compilar o código do Gradle, bem como um plug-in infalível para executar especificações baseadas no groovy. Além deste moderno e Spock, dependências também deve ser adicionado.

org.codehaus.gmavenplus gmavenplus-plugin 1.5 testCompile maven-surefire-plugin 2.18.1 false **/*Spec.java org.spockframework spock-core 1.3-groovy-2.5 test

Para projetos baseados em Gradle

Para um arquivo gradle de amostra conforme abaixo, os requisitos mais importantes incluem o plug-in gradle e as dependências do groovy para código e teste.

plugins { id 'java' id 'groovy' } repositories { mavenCentral() } dependencies { compile 'org.codehaus.groovy:groovy-all:2.4.8' testCompile 'org.spockframework:spock-core:1.1-groovy-2.4' }

Anatomia de uma especificação de Spock

Os testes Spock podem ser escritos para qualquer linguagem executada em JVM. Isso significa que mesmo que o código do seu aplicativo esteja em Java ou Scala ou Kotlin etc., você ainda pode escolher escrever seus testes de unidade / integração em Spock (em vez de outros como JUnit, JBehave, etc.).

As classes de teste de Spock são chamadas de 'Especificações' (semelhantes às especificações no mundo BDD) e você pode estender a classe de 'Especificação' da estrutura de Spock. (Especificação é a classe base do framework Spock).

Cada arquivo de especificação pode conter vários testes (semelhante a um arquivo de classe de teste JUnit) e cada teste pode conter opcionalmente os blocos BDD, ou seja, fornecidos, quando e então. Isso é semelhante a outras estruturas BDD, onde cada uma dessas seções pode ser correlacionada às seções Organizar, Agir e Assertar nos testes JUnit, respectivamente.

Abaixo está um diagrama de blocos que descreve a hierarquia de especificações e testes.

hierarquia de especificações e testes

Vamos ver como uma especificação de amostra se parece no código:

import spock.lang.Specification class SampleSpec extends Specification { def 'check case-insensitive equality of 2 strings'() { given: String str1 = 'hello' String str2 = 'HELLO' when: str1 = str1.toLowerCase() str2 = str2.toLowerCase() then: str1 == str2 } def 'check addition of 2 numbers'() { given: int input1 = 10 int input2 = 25 when: int result = input1 + input2 then: result == 35 } }

Alguns pontos importantes a serem observados aqui:

# 1) Observe o nome dos cenários de teste (a string após a palavra-chave def): “verifique a igualdade sem distinção entre maiúsculas e minúsculas de 2 strings”. Essas são cadeias de caracteres simples em inglês e isso torna os nomes de teste bastante legíveis e dá um sentido real para testar o que é alcançado.

Compare-o com o teste JUnit normal, em que o nome do teste será semelhante a c.

caseEquality_withValidInput_shouldBeEqual()

#dois) Dado, os blocos when e then são equivalentes a Arrange, Act e Assert. Destes, olhe para o then (ou bloco de asserção), que implica a asserção de igualdade e evita todo o código clichê associado às asserções.

Exemplo , Uma afirmação em JUnit teria a aparência mostrada abaixo:

@Test public void compareStrings_withValidInput_shouldReturnSuccess() { // Arrange String str1 = 'hello'; String str2 = 'HELLO'; // Act str1 = str1.toLowerCase(); str2 = str2.toLowerCase(); // Assert Assert.assertEquals(str1,str2); }

Como você pode ver acima, os testes de Spock fazem com que os testes pareçam menos prolixos, bem como evitam todo o código clichê em asserções (e configuração, etc.)

Descrições do bloco de especificações

Para cada um dos blocos individuais em um teste, você pode escolher fornecer a descrição do bloco como uma string para fornecer mais detalhes sobre o bloco que está sendo executado. Isso é útil para fornecer uma estrutura mais detalhada ao teste.

Vamos ver um exemplo abaixo:

def 'check case-insensitive equality of 2 strings'() { given: 'two input strings' String str1 = 'hello' String str2 = 'HELLO' when: 'strings are lowercased' str1 = str1.toLowerCase() str2 = str2.toLowerCase() then: 'equal strings should return success' str1 == str2 }

Dicas importantes

# 1) Todos os blocos em uma especificação baseada em Spock são opcionais. No entanto, se estiver presente, “quando” e “então” devem aparecer juntos em sequência.

#dois) Se você só precisa validar uma afirmação (e não precisa bloquear quando), você pode usar “ Espero ' quadra. Pode ser usado para declarar pré-condições antes mesmo de quando e então bloqueia (e pode ser usado várias vezes em um teste).

Vamos ver um exemplo de uso de esperar, como validar a pré-condição antes de executar o bloco 'quando'.

def 'check addition of 2 numbers'() { given: int input1 = 10 int input2 = 25 expect: input1.getClass().toString() == 'class java.lang.Integer' input2.getClass().toString() == 'class java.lang.Integer' input1 = Integer.MIN_VALUE when: int result = input1 + input2 then: result == 35 }

Conforme mostrado acima, o bloco expect está tentando declarar o valor da classe dos campos de entrada, bem como o valor de uma das entradas dentro do intervalo.

Conclusão

Neste tutorial do Spock, cobrimos os fundamentos da linguagem de programação Groovy, junto com a anatomia ou os blocos de construção básicos de uma Especificação Spock.

Criamos um projeto de amostra com as dependências necessárias para escrever especificações de Spock com base no groovy e escrevemos uma especificação de amostra.

Nos outros tutoriais desta série, vamos nos aprofundar nos recursos fornecidos pela estrutura do Spock e saber como eles usam uma linguagem bacana para criar especificações de teste limpas e legíveis.

quando o teste de regressão deve ser realizado

Fique atento aos nossos próximos tutoriais de Spock para saber mais sobre acessórios de teste, asserções e relatórios em Spock.

PRÓXIMO Tutorial

Leitura recomendada

^