Tests en Java con Groovy y Spock

SPOCKSPOCK
Pruebas en Java con Groovy yPruebas en Java con Groovy y
Andrés ViedmaAndrés Viedma

¿Quién soy?¿Quién soy?
Dinosaurio del software
más de 20 años como profesional
Javero inquieto
Sospechoso habitual del MadridGUG y
MadridJUG
Escribo en Apaga y vuelve a encender
http://apagayvuelveaencender.blogspot.com
@andres_viedma@andres_viedma

Pero... ¿de verdad hacemosPero... ¿de verdad hacemos
pruebas?pruebas?

EL CASTIGADOR DE LOS TESTSEL CASTIGADOR DE LOS TESTS

EL CASTIGADOR DE LOS TESTSEL CASTIGADOR DE LOS TESTS
Da su merecido (o sea, pruebas) a
todas las líneas de código
No hace excepciones

ROBIN HOOD, EL INFALIBLEROBIN HOOD, EL INFALIBLE

ROBIN HOOD, EL INFALIBLEROBIN HOOD, EL INFALIBLE
Nunca falla un tiro.
Ni tampoco falla en el código.
Las pruebas son para los torpes

EL INCREIBLE PINOCHOEL INCREIBLE PINOCHO

EL INCREIBLE PINOCHOEL INCREIBLE PINOCHO
Hace muchíiiiisimas pruebas.
No se lo cree ni él.

EL INFORMÁTICO VAGOEL INFORMÁTICO VAGO

Hacer pruebas es
importante.

Hacer pruebas es
importante.
Es una pena que
también sea
UN COÑAZO

Tests a prueba de VagosTests a prueba de Vagos
Subir nivel de abstracción
No “programar tests” → declarar casos de prueba
Sencillez + potencia
Expresividad → test es a la vez documentación
Fácil de ejecutar en sistemas de integración continua y
en IDEs
Información que facilite la detección de errores

SPOCKSPOCK
Muy parecido a Java (“extensión” del lenguaje)
Compatible con él (se ejecuta en JVM)
Lenguaje dinámico (o no)
Mucho “azúcar sintáctico”
Mucha “magia negra”
Diseñado para maximizar sencillez y expresividad
Tiene su propio runner JUnit
Hecho en Groovy

¡Uf! Para montar eso
voy a necesitar...

<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<compilerId>groovy-eclipse-compiler</compilerId>
</configuration>
<dependencies>
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-eclipse-compiler</artifactId>
<version>2.8.0-01</version>
</dependency>
<dependency>
<artifactId>groovy-eclipse-batch</artifactId>
<version>2.1.8-01</version>
</dependency>
</dependencies>
</plugin>
1. Compilar código Groovy1. Compilar código Groovy

2. Dependencias con Spock2. Dependencias con Spock

<dependency>
<artifactId>groovy-all</artifactId>
<version>2.1.5</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.spockframework</groupId>
<artifactId>spock-core</artifactId>
<version>0.7-groovy-2.0</version>
<scope>test</scope>
</dependency>

3. Ejecutar tests *Spec (opc.)3. Ejecutar tests *Spec (opc.)

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.14</version>
<configuration>
<includes>
<include>**/*Spec.java</include>
<include>**/Test*.java</include>
<include>**/*Test.java</include>
<include>**/*TestCase.java</include>
</includes>
</configuration>
</plugin>

Sólo dependenciasSólo dependencias
apply plugin: 'groovy'
// spock
testCompile 'org.codehaus.groovy:groovy-all:2.1.5'
testCompile(
group:'org.spockframework',name:'spock-core',
version:'0.7-groovy-2.0')

¿IDEs?¿IDEs?
Groovy Eclipse Plugin
– http://groovy.codehaus.org/Eclipse+Plugin
Versiones Eclipse entre 3.5 (Galileo) y 4.3 (Kepler)
Instalar versión adecuada (Extra Groovy compilers – 2.1)
Plugin Groovy incluido en instalación

¿Nada más?¿Nada más?
¡Nada más!
SDK Groovy no hace falta
Requisitos mínimos
JDK 5.0
Probado con Maven 2.0.9 (última 3.2.1...)
Eclipse Galileo
No requiere cambios importantes en entorno de desarrollo

Mi primer test SPOCKMi primer test SPOCK

import spock.lang.Specification;
class SillySpec extends Specification {
def "add two numbers"() {
expect:
1 + 1 == 2
}
}
El test más tonto del mundoEl test más tonto del mundo
src/test/groovy/SillySpec.groovy

import spock.lang.Specification;
class SillySpec extends Specification {
def "add two numbers"() {
expect:
1 + 1 == 2
}
}
El test más tonto del mundoEl test más tonto del mundo
“Assert” implícito
src/test/groovy/SillySpec.groovy

El segundo test más tonto del mundoEl segundo test más tonto del mundo
def "add elements to a list"() {
given:
def list = ["one", "two"]
when:
list.add("three")
list << “four”
then:
list == ["one", "two", "three", "four"]
}

given:
when:
list.add("three")
list << “four”
then:
}
DSL

given:
when:
list.add("three")
list << “four”
then:
}
equals
Tipos opcionales Collection literals
; opcional

Organización en BloquesOrganización en Bloques
given (setup)
when
then
expect
where
cleanup
Estímulo /
respuesta
Comprobación
directa
and: encadenar varios
bloques del mismo
tipo

Organización en BloquesOrganización en Bloques
given (setup)
when
then
expect
where
cleanup
Estímulo /
respuesta
Comprobación
directa
Legibilidad
When/then: efectos laterales
Expect: método funcional puro
and: encadenar varios
bloques del mismo
tipo

Condiciones then / expectCondiciones then / expect
when:
stack.push(elem)
then:
!stack.empty
stack.size() == 1
stack.peek() == elem
Condiciones booleanas
sencillas
when:
stack.pop()
then:
thrown(EmptyStackException)
stack.empty
Condiciones excepciones
thrown / notThrown
Interacciones (...)
Sólo pueden contener condiciones o definición de variables

Tests como documentaciónTests como documentación
@Issue("http://www.mybugtracking.com/BUG-012324")
given: "a list with elements”
when: "two more are added”
list.add("three")
list << “four”
then: "the list includes now both elements”
}

list.add("three")
list << “four”
}
Comportamiento queda
mejor documentado

list.add("three")
list << “four”
}
Comportamiento queda
mejor documentado
Bueno para razonamiento
TDD

Cambio de estadoCambio de estado
def "generate a sequential identifier"() {
given:
def gen = new SequentialIdGenerator()
when:
def id = gen.generateId()
then:
id == old(gen.nextId)
gen.nextId == old(gen.nextId) + 1
}

Cambio de estadoCambio de estado
def "generate a sequential identifier"() {
given:
def gen = new SequentialIdGenerator()
when:
def id = gen.generateId()
then:
id == old(gen.nextId)
gen.nextId == old(gen.nextId) + 1
}
Ojo: no usar si el resultado
es un objeto mutable

Matchers HamcrestMatchers Hamcrest
import static spock.util.matcher.HamcrestMatchers.closeTo
class HamcrestMatchers extends Specification {
def "comparing two decimal numbers"() {
def myPi = 3.14
expect:
myPi closeTo(Math.PI, 0.01)
}
}

Control de la EjecuciónControl de la Ejecución
@Ignore
def "esta no se va a ejecutar"() { }
@Ignore(reason = "porque no funciona ni p'atrás")
def "esta tampoco se va a ejecutar"() { }
@IgnoreRest
def "si lo pongo esta va a ser la única en ejecutarse"() { }
@IgnoreIf({ os.windows })
def "esta solo se ejecutaría en Windows"() { }
@Stepwise
class RunInOrderSpec extends Specification {
def "Este será siempre el primero"() { ... }
def "Este se ejecutará el segundo"() { ... }
}
@Timeout(5)
def "Falla si tarda más de 5 segundos"() { }
Ejecución
selectiva
Timeout
Orden de
ejecución

Tests basados enTests basados en
DatosDatos

@Unroll
def "distance on #descrip"() {
expect:
LevenshteinCalculator.getLevenshteinDistance(s1, s2) == res
(res == 0? s1 == s2 : s1 != s2)
where:
s1 | s2 | descrip || res
"pepito" | "pepito" | "same values" || 0
"pepito" | "pePito" | "only case difference" || 1
"pepito" | "qerida" | "many char differences" || 4
"pepito" | "p" | "shorter value" || 5
"p" | "otro" | "larger value" || 4
"12345" | "6" | "all different" || 5
"" | "1234" | "empty and non empty" || 4
"" | "" | "both empty" || 0
"12 34" | "12 34" | "differences in spaces" || 1
"one vision"| "one visn" | "two chars in the middle" || 2
}
Tablas de datosTablas de datos

@Unroll
expect:
(res == 0? s1 == s2 : s1 != s2)
where:
s1 | s2 | descrip || res
"pepito" | "pepito" | "same values" || 0
"pepito" | "pePito" | "only case difference" || 1
"pepito" | "qerida" | "many char differences" || 4
"pepito" | "p" | "shorter value" || 5
"p" | "otro" | "larger value" || 4
"12345" | "6" | "all different" || 5
"" | "1234" | "empty and non empty" || 4
"" | "" | "both empty" || 0
"12 34" | "12 34" | "differences in spaces" || 1
"one vision"| "one visn" | "two chars in the middle" || 2
}
Tablas de datosTablas de datos
Tests diferenciados

Pipes de datosPipes de datos
@Unroll
expect:
(res == 0? s1 == s2 : s1 != s2)
where:
s1 << ["pepito", "pepito", "pepito", "pepito", "p"]
s2 << ["pepito", "pePito", "qerida", "p", "otro"]
descrip << ["same values", "only case difference",
"many char differences", "shorter value",
"larger value"]
res << [0, 1, 4, 5, 4]
}

@Unroll
expect:
(res == 0? s1 == s2 : s1 != s2)
where:
[s1, s2, descrip, resStr] <<
new File("testdata.csv").readLines()
.collect {line -> line.tokenize(",")}
res = Integer.parseInt(resStr)
}

@Unroll
expect:
(res == 0? s1 == s2 : s1 != s2)
where:
[s1, s2, descrip, resStr] <<
new File("testdata.csv").readLines()
.collect {line -> line.tokenize(",")}
res = Integer.parseInt(resStr)
}
Asignaciones de variables

““Test doubles”Test doubles”
(mock objects)(mock objects)

¿Por qué “test doubles”?¿Por qué “test doubles”?
Problema: test de clase A que usa otra clase B que no
queremos probar:
Porque utiliza recursos externos (BD, APIs externas...)
Para independizar las pruebas
“Test doubles” reemplazan la clase B por objetos “de pega”
Stub: devuelve respuestas prefijadas en el test
Mock: cascarón vacío con respuestas por defecto
Spy: pone una capa sobre un objeto real para espiar las
llamadas que se le hacen

StubsStubs
def "check valid comics"() {
given:
def apiStub = Stub(MarvelApi) {
findComicsByCharacter(_) >> [
new MarvelComic(id: 1, date: new Date(),
creators: [new ComicCreator(id: 101)]
),
(............)
new MarvelComic(id: 6, date: null,
)
]
}
MarvelQuestionnaireFactory f = new MarvelQuestionFactory(apiStub)
expect:
f.loadValidQuestionnarieComics(1)*.id == [1, 5]
}

StubsStubs
given:
),
(............)
)
]
}
expect:
}
Stub de una clase
añadir dependencias a
cglib-nodep y objenesis

StubsStubs
given:
),
(............)
)
]
}
expect:
}
Named parameter constructor

Stubs: constraintsStubs: constraints
Método: admite expresiones regulares
api./findComicsBy.*/(...)
Propiedad (getter)
api.apiKey
Argumentos
stub.metodo("hello")
stub.metodo(!"hello")
stub.metodo()
stub.metodo(_)
stub.metodo(*_)
stub.metodo(_ as String)
stub.metodo({ l -> l.size() > 3 })

Stubs: comportamientoStubs: comportamiento
Siempre devolver mismo valor (>>)
stub.metodo(args) >> result1
Devolver valores secuencialmente (>>>)
stub.metodo(args) >>> [res1, res2, res3]
Ejecución de código (cambio estado, calcular retorno)
stub.metodo(...) >> { args -> ..... }
stub.metodo(...) >> { arg -> ..... }
Encadenar llamadas de distinto tipo
stub.metodo(args) >>> [r1, r2] >> { (code) }
>> r4
Llamada no declarada: valor por defecto / objeto vacío (no null)

Tests basados enTests basados en
InteraccionesInteracciones

External
Event Log
System
Questionnaire
DAO DB
Event Log
API
Questionnaire
Service
No hay resultado
que probar
Añadir unAñadir un
cuestionariocuestionario
Tests de Interacciones: por quéTests de Interacciones: por qué

External
Event Log
System
Questionnaire
DAO DB
Event Log
API
Questionnaire
Service
No hay resultado
que probar
Añadir unAñadir un
cuestionariocuestionario
Tests de Interacciones: por quéTests de Interacciones: por qué
¡¡¡NO
LO PROBAM
OS!!!

Interacción con MocksInteracción con Mocks
def "add a questionnaire"() {
given: "a questionnaire with two questions"
def q = new Questionnaire()
q.addQuestion(new Question())
and: "a service with mocked collaborators"
def dao = Mock(QuestionnaireDao)
def eventLog = Mock(EventLogApi)
def service = new QuestionnaireService(dao, eventLog)
when: "the questionnaire is created"
service.addQuestionnaire(q)
then: "the questionnaire + questions are created, the event logged"
1 * dao.addQuestionnaireBean(_)
2 * dao.addQuestionBean(_)
1 * eventLog.registerEvent
{ ev -> ev.type == EventType.ADD_QUESTIONNAIRE }
}

Interacción con MocksInteracción con Mocks
def "add a questionnaire"() {
given: "a questionnaire with two questions"
def q = new Questionnaire()
and: "a service with mocked collaborators"
def dao = Mock(QuestionnaireDao)
def eventLog = Mock(EventLogApi)
def service = new QuestionnaireService(dao, eventLog)
when: "the questionnaire is created"
service.addQuestionnaire(q)
then: "the questionnaire + questions are created, the event logged"
1 * dao.addQuestionnaireBean(_)
2 * dao.addQuestionBean(_)
1 * eventLog.registerEvent
{ ev -> ev.type == EventType.ADD_QUESTIONNAIRE }
}
Interacción = Cardinalidad * Constraint

Mocks en SpockMocks en Spock
Cardinalidad
Constraints son iguales que en Stubs
Mocking por defecto lenient (“indulgente”)
Estricto - añadir al final regla: 0 * _
Orden de llamadas no se considera
Para hacerlo, poner cada comprobación en un
bloque “then” diferenciado
1 * subscriber.receive("hello")
0 * subscriber.receive("hello")
(1..3) * subscriber.receive("hello")
(1.._) * subscriber.receive("hello")
(_..3) * subscriber.receive("hello")
_ * subscriber.receive("hello")

Shaken, not stirredShaken, not stirred
Interacciones se pueden mezclar con
condiciones de comprobación de datos
Mocks pueden tener métodos stubbeados
Valores por defecto distintos a Stub: 0 / false / null
Spies: wrapper sobre implementación de clase
real
Se pueden chequear interacciones
Se pueden stubbear métodos

Recapitulemos...Recapitulemos...

¿¿¿Tests a prueba de Vagos???¿¿¿Tests a prueba de Vagos???
en IDEs

¿¿¿Tests a prueba de Vagos???¿¿¿Tests a prueba de Vagos???
en IDEs
¡¡¡YESSSSSSSSSSSSS!!!¡¡¡YESSSSSSSSSSSSS!!!

¡¡¡¿¿¿SOMOS HOMBRES¡¡¡¿¿¿SOMOS HOMBRES
O NENAZAS???!!!O NENAZAS???!!!
¿Ibas a alguna parte?...

Tests de integraciónTests de integración

Base de datos (objeto Sql)Base de datos (objeto Sql)
@Shared
@AutoCleanup("shutdown")
DataSource ds = new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL).build();
@Shared
Sql sql = Sql.newInstance(ds)
@Shared
SqlSession session
@Shared
@Subject
QuestionnarieDao dao
def setupSpec() {
// DDL
sql.execute('''
create table questionnaries (
id bigint not null identity,
name varchar(200) not null
);
''')
// MyBatis config / DAO creation
def transactionFactory = new JdbcTransactionFactory();
def environment = new Environment("development", transactionFactory, ds);
def configuration = new Configuration(environment);
configuration.addMapper(QuestionnarieDao.class);
def builder = new SqlSessionFactoryBuilder();
def factory = builder.build(configuration);
session = factory.openSession()
dao = session.getMapper(QuestionnarieDao.class)
}

Base de datos (objeto Sql)Base de datos (objeto Sql)
def "find questionnaries" () {
final NAME = "Cuestionario de prueba"
given:
sql.execute("insert into questionnaries(name) values (${NAME})")
sql.commit()
when:
def qlist = dao.findActiveQuestionnaries()
then:
qlist.size() == 1
qlist[0].name == NAME
}
def "insert questionnarie" () {
final NAME = "Cuestionario nuevo"
when:
dao.insertQuestionnarie(new Questionnarie([name: NAME]))
session.commit()
then:
sql.firstRow("select * from questionnaries where name = ${NAME}").id != null
and:
sql.rows("select * from questionnaries").size() ==
old(sql.rows("select * from questionnaries").size()) + 1
}

Base de datos: DB UnitBase de datos: DB Unit
@Shared
DataSource ds = new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL).build()
(...)
@DbUnit
def dbState = {
Questionnaries(id: 1, name: 'Cuestionario de prueba')
Questionnaries(id: 2, name: 'Otro cuestionario')
Questionnaries(id: 3, name: 'Y otro más')
}
(...)
when:
then:
qlist.size() == 3
qlist[0].name == "Cuestionario de prueba"
}

Base de datos: DB UnitBase de datos: DB Unit
@Shared
DataSource ds = new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL).build()
(...)
@DbUnit
def dbState = {
Questionnaries(id: 1, name: 'Cuestionario de prueba')
Questionnaries(id: 2, name: 'Otro cuestionario')
Questionnaries(id: 3, name: 'Y otro más')
}
(...)
when:
then:
qlist.size() == 3
qlist[0].name == "Cuestionario de prueba"
}
spock-dbunit

SpringSpring
@ContextConfiguration(locations = "classpath:spring/application-config.xml")
class CourseRestControllerSpec extends Specification {
@Autowired
@Subject
CourseRestController controller
def "get courses"() {
when:
ListPage<Course> courses = controller.getCourses(new PaginationDesc(from: 1, max: 10))
then:
courses.listSize == 7
courses.elements[2].title == "Intensivo de rueda cubana"
}
}

SpringSpring
@ContextConfiguration(locations = "classpath:spring/application-config.xml")
class CourseRestControllerSpec extends Specification {
@Autowired
@Subject
CourseRestController controller
def "get courses"() {
when:
ListPage<Course> courses = controller.getCourses(new PaginationDesc(from: 1, max: 10))
then:
courses.listSize == 7
courses.elements[2].title == "Intensivo de rueda cubana"
}
}
spock-spring

TestsTests
FuncionalesFuncionales
(web)(web)

Tests web funcionalesTests web funcionales
class QuestionnariesPageSpec extends GebSpec {
def "questionnaries page check"() {
final EXPECTED_ELEMENT = "Cuestionario chulo"
given:
go "/es/questionnaries"
expect:
$("p.recordcount > .valor").text() == "7"
and:
def link = $("ol.pag-registros > li .media-heading a")[5]
link.text() == EXPECTED_ELEMENT
when:
link.click()
then:
title == EXPECTED_ELEMENT
}
}

GebGeb
Very Groovy Browser Automation
Basado en Selenium
http://www.gebish.org/
Permite hacer capturas (reporting)
<dependency>
<groupId>org.gebish</groupId>
<artifactId>geb-spock</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-htmlunit-driver</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-firefox-driver</artifactId>
<scope>test</scope>
</dependency>
Dependencias
Configuracioń:
/GebConfig.groovy (DSL)
import org.openqa.selenium.htmlunit.HtmlUnitDriver;
driver = { new HtmlUnitDriver() }
baseUrl = "http://xxxxxxxxxxxxxxxxx"
Instalar Drivers
(PhantomJS, Firefox...)

Geb con Page ObjectsGeb con Page Objects
class PaginationModule extends Module {
def root
static content = {
paginationbar { root.find(".paginationbar") }
total { paginationbar.find (".recordcount .valor").text() as int }
pageElements { root.find("ol.pag-registros > li") }
}
}
class QuestionnarieHeader extends Module {
def root
static content = {
link { root.find(".media-heading a") }
description { link.text() }
}
}
class QuestionnariesListPage extends Page {
static url = "/es/questionnaries"
static at = { title == "Registros" }
static content = {
pagination { module PaginationModule,
root: $(".sumario_registros .pagination-container") }
questionnaries { pagination.pageElements.collect
{ module QuestionnarieHeader, root: it } }
}
}

def root
static content = {
}
}
def root
static content = {
}
}
static content = {
}
}
Page object
- url: para ir a la página
- at: para comprobar si estamos
en ella
- content: acceso rápido a
elementos

def root
static content = {
}
}
def root
static content = {
}
}
static content = {
}
}
Module object
Elemento reutilizable por
varias páginas

def root
static content = {
}
}
def root
static content = {
}
}
static content = {
}
}
Forma de usar los módulos
dentro de un page object

def "questionnaries page check"() {
given:
to QuestionnariesListPage
expect:
at QuestionnariesListPage
and:
pagination.total == 7
and:
def quest = questionnaries[5]
quest.description == EXPECTED_ELEMENT
when:
quest.link.click()
then:
waitFor { at QuestionnariePage }
questionnarieTitle == EXPECTED_ELEMENT
}
}

Tests deTests de
AceptaciónAceptación

Pruebas de aceptaciónPruebas de aceptación
@Title("Listado de cuestionarios")
@Narrative(""""
Como creador de juegos de cuestionarios
quiero poder consultar la lista de cuestionarios ya existentes
para poder crear un nuevo cuestionario basado en otro anterior
""")
def "scenario: comprobación listado"() {
given: "Estamos en la lista de cuestionarios"
expect: "Que la página sea la correcta"
and: "El número de elementos sea el correcto"
and: "Se comprueba que uno de los elementos sea el correcto"
when: "Se clica en él"
quest.link.click()
then: "Se comprueba que se va a su ficha y que el título sea el correcto"
}
}
Historia de usuario

@Narrative(""""
""")
quest.link.click()
}
}
Criterios de aceptación

@Narrative(""""
""")
quest.link.click()
}
}
Cooperación cliente,
UX, front, back...

@Narrative(""""
""")
quest.link.click()
}
}
BDD
Behaviour Driven
Development
Cooperación cliente,
UX, front, back...

Más informaciónMás información
Página principal Spock:
http://www.spockframework.org
Documentación:
http://docs.spockframework.org/
Documentación antigua:
http://code.google.com/p/spock/w/list
Spock Web Console
http://meet.spockframework.org/
Proyecto de ejemplo
http://files.spockframework.org/spock-example-0.5-groovy-1.7.zip
Lenguaje Groovy
http://beta.groovy-lang.org/docs/groovy-2.3.1/html/documentation/#_lists
Modificaciones Groovy a librería estándar JDK
http://groovy.codehaus.org/groovy-jdk/

Más informaciónMás información
Geb
http://www.gebish.org/
spock-spring
http://code.google.com/p/spock/wiki/SpringExtension
spock-dbunit
https://github.com/janbols/spock-dbunit

Gracias por la atención...Gracias por la atención...
@andres_viedma@andres_viedma

Tests en Java con Groovy y Spock

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Tests en Java con Groovy y Spock

Semelhante a Tests en Java con Groovy y Spock (20)

Último

Último (6)

Tests en Java con Groovy y Spock