Spock测试套件入门
Spock测试套件
Spock套件基于一个单元测试框架，它有比junit更为简洁高效的测试语法。
核心概念
整体认识
Spock中一个单元测试类名叫Specification。所有的单元测试类，都需要继承Specification
class MyFirstSpecification extends Specification {
// fields
// fixture methods
// feature methods
// helper methods
}
对于spock来说，Specification代表了一个软件、应用、类的使用规范，其中的所有单元测试方法，被称为feature，即功能。
一个feature method的执行逻辑大概是如下几步：
- setup 设置该功能的前置配置
- stimulus 提供一个输入，触发该功能
- response 描述你期望该功能的返回值
- cleanup 清理功能的前置配置
所以，对spock来说，一个单元测试，其实是这个软件应用提供的功能使用规范，这个规范中提供了每个功能的使用说明书，输入什么，会得到什么，大体是按这个看法，去写单元测试的。
前置、后置
就像junit一样，我们可以对整个单元测试类做一些前置，并清理。也可以对每个单元测试的方法做一些前置后清理。
其跟Junit的类比关系为
setupSpec 对应 @BeforeClass
setup 对应 @Before
cleanup 对应 @After
cleanupSpec 对应 @AfterClass
同时由于Spock的单元测试本身是会集成Specification 父类的，所以父类中的前置、后置方法也会被调用，不过不用显示调用，会自动调用。
一个测试功能方法执行时，其整体的执行顺序为：
super.setupSpec
sub.setupSpec
super.setup
sub.setup
**feature method
sub.cleanup
super.cleanup
sub.cleanupSpec
super.cleanupSpec
同junit的类比
Feature 方法
blocks
feature的具体写法有很多的block组成，这些block对应的feature方法本身的四个阶段（setup, stimulus, reponse, cleanup) 。每个block对应阶段示意图
典型的用法
def '测试++'(){
given:
def x = 5
when: def result = calculateService.plusPlus(x)
then: result == 6
}
- given也可以写成setup，feature方法里的given其实跟外面的setup方法功能一样，都是做测试功能的前置设置。只是单独的setup方法，是用来写对每个测试feature都有用的测试。只跟当前feature相关的设置，请放在feature方法内的given标签
- when 标签用来实际调用想要测试的feature
- then 中对when的调用返回进行结果验证，这里不需要写断言，直接写表达式就是断言
异常condition
then中的断言在spock中叫condition。比如Java中的Stack在没有元素时，进行Popup，则会EmptyStackException异常。我们期望它确实会抛出这个异常，那么写法如下
def '异常2'() {
given:
def stack = new Stack()
when:
def result = stack.pop()
then:
EmptyStackException e = thrown()
}
它并不会抛出EmptyStackException，我们要测试这个预期的话，代码如下：
def '异常2'() {
given:
def stack = new Stack()
stack.push("hello world")
when:
stack.pop()
then:
EmptyStackException e = notThrown()
}
then和expect的区别
前面说了when block用来调用，then用来判断预期结果。但有的时候，我们的调用和预期判断并不复杂，那么可以用expect将两者合在一起，比如以下两段代码等价
when:
def x = Math.max(1, 2)
then:
x == 2
expect:
Math.max(1, 2) == 2
cleanup block的用法
def 'cleanup'() {
given:
def file = new File("/some/path")
file.createNewFile()
// ...
cleanup:
file.delete()
}
用于清理feature测试执行后的一些设置，比如打开的文件链接。该操作即便测试的feature出异常，依然会被调用
同样，如果多个测试feature都需要这个cleanup.那么建议将cleanup的资源提到setup方法中，并在cleanup方法中去清理
测试用例中的文本描述
为了让单元测试可读性更高，可以将测试方法中每一部分用文本进行描述，多个描述可以用and来串联
def '异常2'() {
given:'设置stack对象'
def stack = new Stack()
and:'其它变量设施'
stack.push('hello world')
when:'从stack中弹出元素'
def result = stack.pop()
then:'预期会出现的异常'
EmptyStackException e = thrown()
}
Extension
spock通过标注来扩充单元测试的功能
@Timeout指定一个测试方法，或一个设置方法最长可以执行的时间，用于对性能有要求的测试
@Ignore用于忽略当前的测试方法
@IgnoreRest忽略除当前方法外的所有方法，用于想快速的测一个方法
@FailsWith 跟exception condition类似
数据驱动测试
数据表
对于有些功能逻辑，其代码是一样的，只是需要测试不同输入值。按照先前的介绍，最简洁的写法为：
def "maximum of two numbers1"() {
expect:
// exercise math method for a few different inputs
Math.max(1, 3) == 3
Math.max(7, 4) == 4
Math.max(0, 0) == 1
}
缺点：
- Math.max代码需要手动调用三次
- 第二行出错后，第三行不会被执行
- 数据和代码耦合在一起，不方便数据从其它地方独立准备
所以spock引入了数据表的概念，将测试数据和代码分开。典型实例如下：
class MathSpec extends Specification {
def "maximum of two numbers"() {
expect:
Math.max(a, b) == c
where:
a | b || c
1 | 3 || 3
7 | 4 || 7
0 | 0 || 0
}
}
- where语句中，定义数据表。第一行是表头，定义这一列所属的变量。
- 实际代码调用，只需要调用一次。代码中的变量跟数据表中的变量必须一一对应
- 看似一个方法，实际上执行时，spock会根据数据表中的行数，循环迭代执行代码。每一行都是独立于其余行执行，所以有setup和cleanup块，对每一个行的都会重复执行一次
- 并且某一行的数据出错，并不影响其余行的执行
另外的写法
def "maximum of two numbers"(int a, int b ,int c) {
expect:
Math.max(a, b) == c
where:
a | b | c
1 | 3 | 3
7 | 4 | 4
0 | 0 | 1
}
- 变量可以在方法参数中声明，但没必要
- 数据表可以全部用一个竖线来分割，但无法像两个竖线一样清晰的分割输入和输出
更清晰的测试结果展示
class MathSpec extends Specification {
def "maximum of two numbers"() {
expect:
Math.max(a, b) == c
where:
a | b || c
1 | 3 || 3
7 | 4 || 4
0 | 0 || 1
}
}
以上测试代码，数据表中的后两行会执行失败。但从测试结果面板中，不能很好的看到详细结果
使用@Unroll可以将每个迭代的执行结果输出
可以看到面板中实际输出的文本为测试方法的名称。如果像在输出中加上输入输出的变量，来详细展示每个迭代，可以在方法名中使用占位符#variable来引用变量的值。举例如下：
@Unroll
def "maximum of #a and #b is #c"() {
expect:
Math.max(a, b) == c
where:
a | b || c
1 | 3 || 3
7 | 4 || 4
0 | 0 || 1
}
更丰富的数据准备方式
前面的数据表显示的将数据以表格的形式写出来。实际上，数据在where block中的准备还有其它多种方式。
where:
a << [1, 7, 0]
b << [3, 4, 0]
c << [3, 7, 0]
从数据库中查询
@Shared sql = Sql.newInstance("jdbc:h2:mem:", "org.h2.Driver")
def "maximum of two numbers"() {
expect:
Math.max(a, b) == c
where:
[a, b, c] << sql.rows("select a, b, c from maxdata")
}
使用groovy代码赋值
where:
a = 3
b = Math.random() * 100
c = a > b ? a : b
以上几种方式可以混搭。
其中方法名也可以以丰富的表达式引用where block中的变量
def "person is #person.age years old"() {
...
where:
person << [new Person(age: 14, name: 'Phil Cole')]
lastName = person.name.split(' ')[1]
}
基于交互的测试(Interaction Based Testing)
有的时候，我们测试的功能，需要依赖另外的collaborators来测试。这种涉及到多个执行单元之间的交互，叫做交互测试
比如：
class Publisher {
List<Subscriber> subscribers = []
int messageCount = 0
void send(String message){
subscribers*.receive(message)
messageCount++
}
}
interface Subscriber {
void receive(String message)
}
我们想测Publisher，但Publisher有个功能是是发消息给所有的Subscriber。要想测试Publisher的发送功能确实ok，那么需要测试Subscriber的确能收到消息。
使用一个实际的Subscriber实现固然能实现这个测试。但对具体的Subscriber实现造成了依赖，这里需要Mock。使用spock的测试用例如下：
class PublisherTest extends Specification{
Publisher publisher = new Publisher()
Subscriber subscriber = Mock()
Subscriber subscriber2 = Mock() //创建依赖的Subscriber 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") //调用publisher的方法
then:
1*subscriber.receive("hello") //期望subscriber的receive方法能被调用一次
1*subscriber2.receive("hello")//期望subscriber1的receive方法能被调用一次
}
}
以上代码的目的是通过mock来测试当Publisher的send的方法被执行时，且执行参数是'hello'时，subscriber的receive方法一定能被调用，且入参也为‘hello’
对依赖Mock的调用期望，其结构如下
1 * subscriber.receive("hello")
| | | |
| | | argument constraint
| | method constraint
| target constraint
cardinality
cardinality
定义右边期望方法执行的次数，这里是期望执行一次，可能的写法有如下：
1 * subscriber.receive("hello") // exactly one call
0 * subscriber.receive("hello") // zero calls
(1..3) * subscriber.receive("hello") // between one and three calls (inclusive)
(1.._) * subscriber.receive("hello") // at least one call
(_..3) * subscriber.receive("hello") // at most three calls
_ * subscriber.receive("hello") // any number of calls, including zero
target constraint
定义被依赖的对象。可能的写法如下
1 * subscriber.receive("hello") // a call to 'subscriber'
1 * _.receive("hello") // a call to any mock object
Method Constraint
定义在上述对象上期望被调用的方法，可能的写法如下：
1 * subscriber.receive("hello") // a method named 'receive'
1 * subscriber./r.*e/("hello") // a method whose name matches the given regular expression
// (here: method name starts with 'r' and ends in 'e')
Argument Constraints
对被调用方法，期望的入参进行定义。可能写法如下：
1 * subscriber.receive("hello") // an argument that is equal to the String "hello"
1 * subscriber.receive(!"hello") // an argument that is unequal to the String "hello"
1 * subscriber.receive() // the empty argument list (would never match in our example)
1 * subscriber.receive(_) // any single argument (including null)
1 * subscriber.receive(*_) // any argument list (including the empty argument list)
1 * subscriber.receive(!null) // any non-null argument
1 * subscriber.receive(_ as String) // any non-null argument that is-a String
1 * subscriber.receive(endsWith("lo")) // any non-null argument that is-a String
1 * subscriber.receive({ it.size() > 3 && it.contains('a') })
// an argument that satisfies the given predicate, meaning that
// code argument constraints need to return true of false
// depending on whether they match or not
// (here: message length is greater than 3 and contains the character a)
一些通配符
1 * subscriber._(*_) // any method on subscriber, with any argument list
1 * subscriber._ // shortcut for and preferred over the above
1 * _._ // any method call on any mock object
1 * _ // shortcut for and preferred over the above
严格模式(Strict Mocking)
when:
publisher.publish("hello")
then:
1 * subscriber.receive("hello") // demand one 'receive' call on 'subscriber'
_ * auditing._ // allow any interaction with 'auditing'
0 * _ // don't allow any other interaction
默认情况下，你对Mock实例的方法的调用，会返回该方法返回值的默认值，比如该方法返回的是布尔型，那么你你调用mock实例中的该方法时，将返回布尔型的默认值false.
如果我们希望严格的限定Mock实例的各方法行为，可以通过上述代码，对需要测试的方法显示定义期望调用行为，对其它方法设置期望一次都不调用。以上then block中的0 * _ 即是定义这种期望。当除subscriber中的receive和auditing中的所有方法被调用时，该单元测试会失败，因为这不符合我们对其它方法调用0次的期望
调用顺序
then:
2 * subscriber.receive("hello")
1 * subscriber.receive("goodbye")
以上两个期望被调用的顺序是随机的。如果要保证调用顺序，使用两个then
then:
2 * subscriber.receive("hello")
then:
1 * subscriber.receive("goodbye")
Stubbing 定义方法返回
前面的interaction mock是用来测试被mock的对象，期望方法的调用行为。比如入参，调用次数。
而stubbing则用来定义被mock的实例，在调用时返回的行为
总结，前者定义调用行为期望，后者定义返回行为期望。且Interaction test 测试的是执行期望或断言。的stubbing则是用来定义mock的模拟的行为。
所以stubbing 对mock方法返回值的定义应该放在given block. 而对mock方法本身的调用Interaction test 应该放在then block中。所以stubbing对返回值的定义相当于在定义测试的测试数据。
Stubbing的使用场景也很明确。假设Publisher需要依赖Subscriber方法的返回值，再做下一步操作。那我们就需要对Subscriber的返回值进行mock，来测试不同返回值对目标测试代码(feature)的行为。
我们将上述Subscriber接口对应的方法添加一个返回值
class Publisher {
Subscriber subscriber
int messageCount = 0
int send(String message){
if(subscriber.receive(message) == 'ok') {
this.messageCount++
}
return messageCount
}
}
interface Subscriber {
String receive(String message)
}
测试代码举例
Publisher publisher = new Publisher()
Subscriber subscriber = Mock()
def setup() {
publisher.subscriber = subscriber
}
def "should send msg to subscriber"() {
given:
subscriber.receive("message1") >> "ok"
when:
def result = publisher.send("message1")
then:
result == 1
}
以上代码表示，模拟subscriber.receive被调用时，且调用参数为message1，方法返回ok. 而此时期望(断言)Publisher的send方法，返回的是1
stubbing 返回值结构
subscriber.receive(_) >> "ok"
| | | |
| | | response generator
| | argument constraint
| method constraint
target constraint
注意这里多了response generator，并且没有interaction test中的Cardinality
各种返回值定义
返回固定值
subscriber.receive("message1") >> "ok"
subscriber.receive("message2") >> "fail"
顺序调用返回不同的值
subscriber.receive(_) >>> ["ok", "error", "error", "ok"]
第一次调用返回ok,第二次、三次调用返回error。剩下的调用返回ok
根据入参计算返回值
subscriber.receive(_) >> { args -> args[0].size() > 3 ? "ok" : "fail" }
subscriber.receive(_) >> { String message -> message.size() > 3 ? "ok" : "fail" }
上述两者效果都一样，都是对第一个入参的长度进行判断，然后确定返回值
返回异常
subscriber.receive(_) >> { throw new InternalError("ouch") }
链式返回值设定
subscriber.receive(_) >>> ["ok", "fail", "ok"] >> { throw new InternalError() } >> "ok"
前三次调用依次返回ok,fail,ok。第四次调用返回异常，之后的调用返回ok
将Interaction Mock和stubbing组合
1 * subscriber.receive("message1") >> "ok"
1 * subscriber.receive("message2") >> "fail"
这里即定义了被mock 的subscriber其方法返回值，也定义了该方法期望被调用多少次。举例：
Publisher publisher = new Publisher()
Subscriber subscriber = Mock()
def setup() {
publisher.subscriber = subscriber
}
def "should send msg to subscriber"() {
given:
1*subscriber.receive("message1") >> "ok"
when:
def result = publisher.send("message1")
then:
result == 1
}
以上写法，即测试了subscriber.receive被调用了一次，也测试了publisher.send执行结果为1．如果将Interaction Mock和stubbing组合拆开，像下面这种写法是不行的：
Publisher publisher = new Publisher()
Subscriber subscriber = Mock()
def setup() {
publisher.subscriber = subscriber
}
def "should send msg to subscriber"() {
given:
subscriber.receive("message1") >> "ok"
when:
def result = publisher.send("message1")
then:
result == 1
1*subscriber.receive("message1")
}
如何创建单元测试类
方式一
像Junit一样，在需要测试的类上，使用Idea的帮助快捷键，然后弹出
选择指定的测试框架spock和路径即可
方式二
直接在指定的测试目录下，新建对应的测试类，注意是新建groovy class
在Idea中，groovy class的图标是方块，java class是圆形，注意区分
有可能建完后，对应的图标是
，说明Ide没有识别到这是个groovy 类，一般是由于其代码有问题，可以打开该文件，把具体的错误修复，比如把注释去掉之类的
参考资料
http://spockframework.org/spock/docs/1.1/all_in_one.html#_introduction
