Question

我有两个Spock规范，都是从不同的起点测试一个长程序，所以它就像

@Stepwise
class FooSpec extends Specification {
    def "setup1"() {...}
    def "setup2"() {...}
    def "common1"() {...}
    def "common2"() {...}
    ...
}

@Stepwise
class BarSpec extends Specification {
    def "setup3"() {...}
    def "setup4"() {...}
    def "common1"() {...}
    def "common2"() {...}
    ...
}

现在我想重构我的代码来重复删除所有常见的*功能方法，这些方法将在不同的设置之后执行。

我尝试使用子类化，但是超类的特征方法在之前执行而不是在子类之后执行。我还尝试编写自己的Spock扩展（Spock版本0.7 for Groovy 2），但是找不到在那里实现我想要的行为的方法。

Answer 1

将common*方法放在基类中，并使用setupSpec()方法（而不是setup*方法）添加两个子类。

Answer 2

咨询StepwiseExtension的源代码，我终于找到了自己的解决方案：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@ExtensionAnnotation(BeforeSuperExtension)
@interface BeforeSuper {}

此注释标记@Stepwise测试中的要素方法，应在super的要素方法之前执行。

扩展实现将相应地重新安排执行顺序：

class BeforeSuperExtension extends AbstractAnnotationDrivenExtension<BeforeSuper>
{
    def beforeSuper = []

    @Override
    void visitFeatureAnnotation(BeforeSuper annotation, FeatureInfo feature)
    {
        beforeSuper << feature
    }

    @Override
    void visitSpec(SpecInfo spec)
    {
        def superFeatures = spec.superSpec.allFeaturesInExecutionOrder
        def afterSuper = spec.features - beforeSuper

        (beforeSuper + superFeatures + afterSuper).eachWithIndex { f, i ->
            f.executionOrder = i
        }
    }
}

Answer 3

我实现了相反的策略，注释@AfterSubSpec告诉超类中的常用方法在子类中的方法之后运行：

class AfterSubSpecExtension extends AbstractAnnotationDrivenExtension<AfterSubSpec> {

    def afterSub = []

    @Override
    void visitFeatureAnnotation(AfterSubSpec annotation, FeatureInfo feature) {
        afterSub << feature
    }

    @Override
    void visitSpec(SpecInfo spec) {
        def subSpecFeatures = spec.bottomSpec.allFeaturesInExecutionOrder - afterSub

        (subSpecFeatures + afterSub).eachWithIndex { f, i -> f.executionOrder = i }
    }
}

如何在@Stepwise Spock规范中重用特征方法？

3 个答案: