grails - 如何重复 Spock 测试？

Question

如此处所述， @Repeat目前不支持注释。如何将 spock 测试标记为重复 n 次？

假设我有 spock 测试：

def "testing somthing"() {
    expect:
    assert myService.getResult(x) == y

    where:
    x | y
    5 | 7
    10 | 12
}

如何将其标记为重复 n 次？

Answer 1

您可以@Unroll像这样使用注释：

@Unroll("test repeated #i time")
def "test repeated"() {
    expect:
        println i
    where:
        i << (1..10)
}

它将为您创建 10 个单独的测试。

编辑您的问题后编辑，使用最简单的方法来实现这一点：

def "testing somthing"() {
    expect:
        assert myService.getResult(x) == y

    where:
        x | y
        5 | 7
        5 | 7
        5 | 7
        5 | 7
        5 | 7
        10 | 12
        10 | 12
        10 | 12
        10 | 12
        10 | 12

}

这是目前在 spock 中执行此操作的唯一方法。

Answer 2

您可以使用 where-block，如上面的答案所示。目前没有办法重复已经有 where 块的方法。

Answer 3

我在这里找到了可行的解决方案（ru）

import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.ElementType
import java.lang.annotation.Target
import org.spockframework.runtime.extension.ExtensionAnnotation
import org.spockframework.runtime.extension.AbstractAnnotationDrivenExtension
import org.spockframework.runtime.model.FeatureInfo
import org.spockframework.runtime.extension.AbstractMethodInterceptor
import org.spockframework.runtime.extension.IMethodInvocation

@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.METHOD, ElementType.TYPE])
@ExtensionAnnotation(RepeatExtension.class)
public @interface Repeat {
    int value() default 1;
}

public class RepeatExtension extends AbstractAnnotationDrivenExtension<Repeat> {

    @Override
    public void visitFeatureAnnotation(Repeat annotation, FeatureInfo feature) {
        feature.addInterceptor(new RepeatInterceptor(annotation.value()));
    }
}

private class RepeatInterceptor extends AbstractMethodInterceptor{
    private final int count;

    public RepeatInterceptor(int count) {
        this.count = count;
    }

    @Override
    public void interceptFeatureExecution(IMethodInvocation invocation) throws Throwable {
        for (int i = 0; i < count; i++) {
            invocation.proceed();
        }
    }
}

Answer 4

使用下面的代码片段为一组值迭代 Spock 测试

def "testing somthing"() {
    expect:
    assert myService.getResult(x) == y

    where:
    x >> [3,5,7]
    y >> [5,10,12]
}

Answer 5

我找到了一种将其组合在一起的简单方法。Spock 允许您将方法的返回通过管道传递到 where 子句中定义的变量中，因此使用它您可以定义一个简单地循环多次数据然后返回组合列表的方法。

def "testing somthing"() {
    expect:
    assert myService.getResult(x) == y

    where:
    [x,y] << getMap()
}


public  ArrayList<Integer[]> getMap(){
    ArrayList<Integer[]> toReturn = new ArrayList<Integer[]>();
    for(int i = 0; i < 5; i ++){
        toReturn.add({5, 7})
        toReturn.add({10, 12})
    }
    return toReturn;
}