Spock测试套件入门

目录
  • Spock测试套件
  • 核心概念
    • 整体认识
    • 前置、后置
  • 同junit的类比
  • Feature 方法
    • blocks
    • 典型的用法
    • 异常condition
    • then和expect的区别
    • cleanup block的用法
    • 测试用例中的文本描述
  • Extension
  • 数据驱动测试
    • 数据表
    • 另外的写法
    • 更清晰的测试结果展示
    • 更丰富的数据准备方式
  • 基于交互的测试(Interaction Based Testing)
    • 对依赖Mock的调用期望,其结构如下
    • 一些通配符
    • 严格模式(Strict Mocking)
    • 调用顺序
  • Stubbing 定义方法返回
    • stubbing 返回值结构
    • 各种返回值定义
  • 将Interaction Mock和stubbing组合
  • 如何创建单元测试类
    • 方式一
    • 方式二
  • 参考资料

Spock测试套件

Spock套件基于一个单元测试框架,它有比junit更为简洁高效的测试语法。

核心概念

整体认识

Spock中一个单元测试类名叫Specification。所有的单元测试类,都需要继承Specification

class MyFirstSpecification extends Specification {
  // fields
  // fixture methods
  // feature methods
  // helper methods
}

对于spock来说,Specification代表了一个软件、应用、类的使用规范,其中的所有单元测试方法,被称为feature,即功能。

一个feature method的执行逻辑大概是如下几步:

  1. setup 设置该功能的前置配置
  2. stimulus 提供一个输入,触发该功能
  3. response 描述你期望该功能的返回值
  4. 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的类比

Spock测试套件入门_第1张图片

Feature 方法

blocks

feature的具体写法有很多的block组成,这些block对应的feature方法本身的四个阶段(setup, stimulus, reponse, cleanup) 。每个block对应阶段示意图

Spock测试套件入门_第2张图片

典型的用法

    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
    }

缺点:

  1. Math.max代码需要手动调用三次
  2. 第二行出错后,第三行不会被执行
  3. 数据和代码耦合在一起,不方便数据从其它地方独立准备

所以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
  }
}

以上测试代码,数据表中的后两行会执行失败。但从测试结果面板中,不能很好的看到详细结果
Spock测试套件入门_第3张图片

使用@Unroll可以将每个迭代的执行结果输出
Spock测试套件入门_第4张图片

可以看到面板中实际输出的文本为测试方法的名称。如果像在输出中加上输入输出的变量,来详细展示每个迭代,可以在方法名中使用占位符#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
    }

Spock测试套件入门_第5张图片

更丰富的数据准备方式

前面的数据表显示的将数据以表格的形式写出来。实际上,数据在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 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测试套件入门_第6张图片

选择指定的测试框架spock和路径即可

方式二

直接在指定的测试目录下,新建对应的测试类,注意是新建groovy class
在Idea中,groovy class的图标是方块,java class是圆形,注意区分

有可能建完后,对应的图标是

,说明Ide没有识别到这是个groovy 类,一般是由于其代码有问题,可以打开该文件,把具体的错误修复,比如把注释去掉之类的

参考资料

http://spockframework.org/spock/docs/1.1/all_in_one.html#_introduction

你可能感兴趣的:(Spock测试套件入门)