Spock集成入门

本文基于SpringBoot

在pom.xml添加Spock依赖

        <!-- test -->
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.4.</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(,) ==
     }

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

         where:
           a|b|c
           ||
           ||
           ||
     }

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

         where:
         a|b|c
         ||
         ||
         ||
     }

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

         where:
         a|b|c
         ||
         ||
         ||
     }

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

         where:
             a|_
             |_
             |_
             |_

             b<<[,,]

             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() == ;
           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:
         *subscriber.receive("hello")
         *subscriber2.receive("hello")
     }
     // 上面的例子里验证了：在publisher调用send时，两个subscriber都应该被调用一次receive(“hello”)。
109 }

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

 * subscriber.receive("hello")      // exactly one call
 * subscriber.receive("hello")      // zero calls
(..) * subscriber.receive("hello") // between one and three calls (inclusive)
(.._) * subscriber.receive("hello") // at least one call
(_..) * subscriber.receive("hello") // at most three calls
_ * subscriber.receive("hello")      // any number of calls, including zero
 * subscriber.receive("hello")     // an argument that is equal to the String "hello"
 * subscriber.receive(!"hello")    // an argument that is unequal to the String "hello"
 * subscriber.receive()            // the empty argument list (would never match in our example)
 * subscriber.receive(_)           // any single argument (including null)
 * subscriber.receive(*_)          // any argument list (including the empty argument list)
 * subscriber.receive(!null)       // any non-null argument
 * subscriber.receive(_ as String) // any non-null argument that is-a String
 * subscriber.receive({ it.size() >  }) // an argument that satisfies the given predicate
                                          // (here: message length is greater than 3)
 * subscriber._(*_)     // any method on subscriber, with any argument list
 * subscriber._         // shortcut for and preferred over the above
 * _._                  // any method call on any mock object
 * _                    // 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:
*subscriber.receive("message1")>>"ok"
*subscriber.receive("message2")>>"fail"

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

setup:
subscriber.receive("message1")>>"ok"

when:
publisher.send("message1")

then:
*subscriber.receive("message1")

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

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