linux打桩数框架,Spock测试框架

介绍

Spock是一个为groovy和java语言应用程序来测试和规范的框架。这个框架的突出点在于它美妙和高效表达规范的语言。得益于JUnit runner，Spock能够在大多数IDE、编译工具、持续集成服务下工作。Spock的灵感源于JUnit,jMock, RSpec, Groovy, Scala, Vulcans以及其他优秀的框架形态。

PS：如果有使用dubbo的同学，这里推荐一个dubbo-postman工具:dubbo-postman

基本概念描述

Spock要求具备基本的groovy和单元测试知识。如果是java程序员，则不需要对groovy感到陌生，因为会java基本就会使用groovy了。

Spock测试类的一般结构

首先看一下测试模板方法的定义和JUnit的对比：

和JUnit对比

Spock基于Groovy,所以像写java测试类一样，需要先创建一个groovy文件。

在一个groovy文件里面的第一行：import spock.lang.*,同时这个类需要继承Specification。

举例:

class MyFirstSpecification extends Specification {

// 变量字段

// 测试模板方法

// 测试方法

// 测试帮助方法

}

Spock的模板方法说明：

def setupSpec() {} // runs once - before the first feature method

def setup() {} // runs before every feature method

def cleanup() {} // runs after every feature method

def cleanupSpec() {} // runs once - after the last feature method

定义变量：

def obj = new ClassUnderSpecification()

def coll = new Collaborator()

定义测试方法：

def "pushing an element on the stack"() {

// 测试代码块，最重要的地方

}

代码块结构和测试各个概念阶段的映射：

测试代码块各阶段映射

代码块结构在def定义的方法内容里面：

given:

def stack = new Stack()

def elem = "push me"

when: // 执行需要测试的代码

then: // 验证执行结果

条件判断：

when:

stack.push(elem)

then:

!stack.empty

stack.size() == 1

stack.peek() == elem

条件不满足的情况输出结果举例:

Condition not satisfied:

stack.size() == 2

| | |

| 1 false

[push me]

验证抛出异常举例：

when:

stack.pop()

then:

thrown(EmptyStackException)

stack.empty

访问异常内容：

when:

stack.pop()

then:

def e = thrown(EmptyStackException)

e.cause == null

验证不会抛出异常举例：

//hashmap允许null的key

def "HashMap accepts null key"() {

given:

def map = new HashMap()

when:

map.put(null, "elem")

then:

notThrown(NullPointerException)

}

基于测试的交互，通过mock构造依赖的外部对象

def "events are published to all subscribers"() {

given:

def subscriber1 = Mock(Subscriber)//通过Mock构造一个依赖的对象

def subscriber2 = Mock(Subscriber)

def publisher = new Publisher()

publisher.add(subscriber1)

publisher.add(subscriber2)

when:

publisher.fire("event")

then:

1 * subscriber1.receive("event")//验证方法名为receive，以及参数"event"为的方法执行一次

1 * subscriber2.receive("event")

}

expect代码块：

expect:

Math.max(1, 2) == 2

cleanup代码块

given:

def file = new File("/some/path")

file.createNewFile()

// ...

cleanup:

file.delete()

where代码块，可能是Spock最厉害的地方了：

def "computing the maximum of two numbers"() {

expect:

Math.max(a, b) == c

where:

a << [5, 3]//执行两次测试，值依次为5，3，下面类似

b << [1, 9]

c << [5, 9]

}

测试的时候帮助方法的处理：

def "offered PC matches preferred configuration"() {

when:

def pc = shop.buyPc()

then:

pc.vendor == "Sunny"

pc.clockRate >= 2333

pc.ram >= 4096

pc.os == "Linux"

}

额外定义一个帮助方法：

def "offered PC matches preferred configuration"() {

when:

def pc = shop.buyPc()

then:

matchesPreferredConfiguration(pc)

}

def matchesPreferredConfiguration(pc) {

pc.vendor == "Sunny"

&& pc.clockRate >= 2333

&& pc.ram >= 4096

&& pc.os == "Linux"

}

输出结果，结果没有显示具体的哪个判断失败了：

Condition not satisfied:

matchesPreferredConfiguration(pc)

| |

false ...

使用assert可以达到这个目的：

void matchesPreferredConfiguration(pc) {

assert pc.vendor == "Sunny"

assert pc.clockRate >= 2333

assert pc.ram >= 4096

assert pc.os == "Linux"

}

最终输出结果，可以看到具体的错误条件：

Condition not satisfied:

assert pc.clockRate >= 2333

| | |

| 1666 false

...

在预期值断言的时候使用with：

def "offered PC matches preferred configuration"() {

when:

def pc = shop.buyPc()

then:

with(pc) {

vendor == "Sunny"

clockRate >= 2333

ram >= 406

os == "Linux"

}

}

使用mock对象的时候也可以用with：

def service = Mock(Service) // has start(), stop(), and doWork() methods

def app = new Application(service) // controls the lifecycle of the service

when:

app.run()

then:

with(service) {

1 * start()

1 * doWork()

1 * stop()

}

当多个预期值一起断言的时候使用verifyAll :

def "offered PC matches preferred configuration"() {

when:

def pc = shop.buyPc()

then:

verifyAll(pc) {

vendor == "Sunny"

clockRate >= 2333

ram >= 406

os == "Linux"

}

}

在没有对象参数的时候也可以这样：

expect:

verifyAll {

2 == 2

4 == 4

}

文档规范：

given: "open a database connection"

// code goes here

and可以增加多个使代码根据可读性：

given: "open a database connection"

// code goes here

and: "seed the customer table"

// code goes here

and: "seed the product table"

// code goes here

测试行为规范的一般模式：

给定条件....

当怎么样的时候...

应该怎样

given: "an empty bank account"

// ...

when: "the account is credited $10"

// ...

then: "the account's balance is $10"

// ...

扩展注解：

@Timeout 设置方法执行的时间

@Ignore 跳过这个测试方法和JUnit类似

@IgnoreRest 跳过其他所有的测试方法，只执行这个测试方法

数据驱动测试

在where里面可以通过数据表格，数据管道，指定变量三种情况对不同的测试case进行赋值，特别是在当需要测试很多种情况的的时候，这个模式具有非常高的可读性和简洁性：

...

where:

a | _

3 | _

7 | _

0 | _

b << [5, 0, 0]

c = a > b ? a : b

基于测试的交互

场景如下，一个发送者向多个订阅者发送消息

class PublisherSpec extends Specification {

Publisher publisher = new Publisher()

Subscriber subscriber = Mock()

Subscriber subscriber2 = Mock()

def setup() {

publisher.subscribers << subscriber // << is a Groovy shorthand for List.add()

publisher.subscribers << subscriber2

}

期待执行一次接收方法：

def "should send messages to all subscribers"() {

when:

publisher.send("hello")

then:

1 * subscriber.receive("hello")

1 * subscriber2.receive("hello")

}

断言表达式解释：

1 * subscriber.receive("hello")

| | | |

| | | 关联参数

| | 关联目标方法

| 关联目标对象

执行次数

在mock创建的时候可以定义多个交互行为：

class MySpec extends Specification {

Subscriber subscriber = Mock {

1 * receive("hello")

1 * receive("goodbye")

}

}

一个测试代码的多个交互通过when区分：

when:

publisher.send("message1")

then:

1 * subscriber.receive("message1")

when:

publisher.send("message2")

then:

1 * subscriber.receive("message2")

结果输出：

Too many invocations for:

2 * subscriber.receive(_) (3 invocations)

打桩：

很多时候我们测试的时候不需要执行真正的方法，因为在测试代码里面构建一个真实的对象是比较麻烦的，特别是使用一些依赖注入框架的时候，因此有了打桩的功能：

interface Subscriber {

String receive(String message)

}

模拟返回值：

subscriber.receive(_) >> "ok"

表达式解释：

subscriber.receive(_) >> "ok"

| | | |

| | | 任何参数的这个方法调用都会返回"ok"

| | argument constraint

| method constraint

target constraint

需要调用多次返回不同结果的时候可以这样定义：

subscriber.receive(_) >>> ["ok", "error", "error", "ok"]

有时候我们测试的一个方法调用了类的其他方法，而其他的方法可能依赖了外部的对象，为了避免引入外部对象，可以使用部分mock功能减少构建外部对象的繁琐：

// this is now the object under specification, not a collaborator

MessagePersister persister = Spy {

// 这个方法的任意参数调用都返回true

isPersistable(_) >> true

}

when:

persister.receive("msg")

then:

// when里面的receive会调用persist，前提是isPersistable是true，因为mock的值是true，这个方法一定会被调用

1 * persister.persist("msg")

和springboot集成

spring本身提供了spring-test测试模块，需要和Spock一起使用的话，只需要在Specification类上面加上SpringApplicationConfiguration这个注解就可以了，如果是mvc应用还需加上WebAppConfiguration这个，其他的使用和原来一样。

maven配置

在pom.xml里面添加

org.spockframework

spock-core

1.2-groovy-2.4

test

org.codehaus.groovy

groovy-all

2.4.15

maven-surefire-plugin

2.20.1

false

**/*Test.java

**/*Spec.java

总结

Spock整体上是一个规范描述型的测试框架，测试代码非常易读。对于java程序员，上手非常容易，在学习的时候可以先在一个项目上使用，当你发下它的优点的时候，你会尽可能的把其他的测试代码也改成用Spock来写，这个过程可能会花费你更多的时间，但是当你熟悉了以后，它带给你的收益一定是值得的。不要犹豫，学习新框架最快的方式就是马上动手。

参考链接