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，不限制次數。