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