Spock集成入门

本文基于SpringBoot

在pom.xml添加Spock依赖

        <!-- test -->
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.4.12</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
        <groupId>org.spockframework</groupId>
        <artifactId>spock-core</artifactId>
        <version>1.1-groovy-2.4</version>
        <scope>test</scope>
        </dependency>

新建Sum.java

public class Sum {
    public int sum(int a, int b) {
        return a + b;
    }
}

新建groovy测试脚本SpockSpecification.groovy

package com.test.bookup

import com.example.demo.Sum
import spock.lang.Specification
import spock.lang.Unroll;

/**
 * Created by hande on 2018/7/18.
 */
class SpockSpecification extends  Specification{

    // 调用外部类测试
    def sum = new Sum();
    def "get sum"(){
        expect:
        sum.sum(1,1) == 2
    }

    // Where Blocks 简单大小比较函数测试
    def "get max num"(){
        expect:
          Math.max(a,b) == c

        where:
          a|b|c
          1|2|2
          1|2|2
          2|3|3
    }

    def "get min num"(){
        expect:
        Math.min(a,b) == c

        where:
        a|b|c
        1|2|1
        1|2|1
        2|3|2
    }

    // 上述例子实际会跑三次测试，相当于在for循环中执行三次测试，如果在方法前声明@Unroll，则会当成三个方法运行。
    @Unroll
    def "@Unroll test"(){
        expect:
        Math.min(a,b) == c

        where:
        a|b|c
        1|2|1
        1|2|1
        2|3|2
    }

    // where block另外两种数据定义方法
    def "where block data init method"(){
        expect:
            Math.max(a,b) == c

        where:
            a|_
            3|_
            7|_
            0|_

            b<<[5,0,0]

            c=a>b?a:b
    }



    // When and Then Blocks
    def "When and Then Blocks"(){
        setup:
          def stack = new Stack();
          def em = "push me";

        when:
          stack.push(em);

        then:
          !stack.empty();
          stack.size() == 1;
          stack.peek() == em;
    }



    // mock应用
    Publisher publisher = new Publisher()
    Subscriber subscriber = Mock()
    Subscriber subscriber2 = Mock()

    def setup() {
        publisher.subscribers.add(subscriber)
        publisher.subscribers.add(subscriber2)
    }

    def"should send messages to all subscribers"(){
        when:
        publisher.send("hello")

        then:
        1*subscriber.receive("hello")
        1*subscriber2.receive("hello")
    }
    // 上面的例子里验证了：在publisher调用send时，两个subscriber都应该被调用一次receive(“hello”)。
109 }

表达式中的次数、对象、函数和参数部分说明

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
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({ it.size() > 3 }) // an argument that satisfies the given predicate
                                          // (here: message length is greater than 3)
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

Stubbing

对mock对象定义函数的返回值可以用如下方法：

subscriber.receive(_)>>"ok"

符号代表函数的返回值，执行上面的代码后，再调用subscriber.receice方法将返回ok。如果要每次调用返回不同结果，可以使用：

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

如果要做额外的操作，如抛出异常，可以使用：

subscriber.receive(_)>>{thrownewInternalError("ouch")}

而如果要每次调用都有不同的结果，可以把多次的返回连接起来：

subscriber.receive(_) >>> ["ok", "fail", "ok"] >> { throw new InternalError() } >> "ok"

mock and stubbing

如果既要判断某个mock对象的交互，又希望它返回值的话，可以结合mock和stub，可以这样：

then:
1*subscriber.receive("message1")>>"ok"
1*subscriber.receive("message2")>>"fail"

注意，spock不支持两次分别设定调用和返回值，如果把上例写成这样是错的：

setup:
subscriber.receive("message1")>>"ok"
 
when:
publisher.send("message1")
 
then:
1*subscriber.receive("message1")

此时spock会对subscriber执行两次设定：

第一次设定receive(“message1”)只能调用一次，返回值为默认值（null）。
第二次设定receive(“message1”)会返回ok，不限制次数。