Spock中的TestNG数据提供程序的类似物

Question

I'm new to Spock, and currently switching to it, but I inherited plenty of test configuration files which need to be re-used. Each config file is a JSON, having the same name as Spec class. For each test method there is a list of maps with parameters, eg:

LoginSpec.json:
{
  "My first test": [
    {
      "user": "user_one",
      "role": "ADMIN"
    },
    {
      "user": "user_two",
      "role": "REPORTER",
      "other_param": "other"
    }
  ],

  "Some Other Test Method": [
    {
      "url": "/lab1",
      "button_name": "Show news popup"
    }
  ]
}

TestNG allowed me to pass test method name in data provider method, so I could return the list of maps depending on test class name and test method name. I had only one data provider method in my base class:

public Object[][] getData(String method) {
    DataReader reader = new JsonReader()
    return reader.parse(packageFullName, getClass().simpleName, method)
}

As a result of this method I get an array of Maps to use in each of test iteration. And then I just specify this method as a DataProvider:

@Test(dataProvider = "getData", priority = 1)
void EULA_1(Map data) { <====
    Pages.login.openLoginPage()
    Pages.login.logIn(data.user) <====
    ...
} 

This works perfectly: declared ones in the base class, it automatically receives the test and provides test data.

The question is: is there a way to apply similar approach in Spock tests?

I'd like to have some getData() method in my base class, where I'm able to read tests parameters depending on the test method name and then pass them into where block.

I tried to use my json reader as shown below:

def "My first test"() {
    setup:
    println(data)

    when:
    ...
    then:
    ...

    where:
    data = dataReader.parse("JobE2E", "LoginSpec.json", "My first test")
}

This example gives me required list of maps, but has two problems:

1. data here - is the full list of maps, not one map for each iteration;
2. I'm forced to explicitly type the name of test method, class etc.

Summing up: What is the best way to implement a data provider which will receive test method name and return a list of maps?

Answer 1

You can solve problem with data using this approach:

data << dataReader.parse('JobE2E', "${getClass().name}.json", 'My first test')

It will iterate the list of maps so each test iteration will be parametrized only by that map.

---

Current test name can be obtained by:

specificationContext.currentFeature.name

And current iteration name by:

specificationContext.currentIteration.name

But both are not accessible in the where section because it is executed before the test itself where only values from shared context are available. So here I'm afraid that you have to enter the test name manually.

Update: I found solution how to get feature name in where section for you. It is realized by an own extension using interceptor.

Feature details container:

class FeatureDetails {
    String name
}

Extension annotation:

import org.spockframework.runtime.extension.ExtensionAnnotation

import java.lang.annotation.ElementType
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ExtensionAnnotation(FeatureDetailsExtension.class)
@interface ShareFeatureDetails {
}

Spock extension with inline interceptor implementation:

import org.spockframework.runtime.extension.AbstractAnnotationDrivenExtension
import org.spockframework.runtime.model.FeatureInfo

class FeatureDetailsExtension extends AbstractAnnotationDrivenExtension<ShareFeatureDetails> {
    def featureDetails = new FeatureDetails()

    @Override
    void visitFeatureAnnotation(ShareFeatureDetails annotation, FeatureInfo feature) {
        feature.addInterceptor({ i ->
            featureDetails.name = feature.name
            feature.spec.allFields.each { f ->
                if (f.type == FeatureDetails.class && f.readValue(i.getInstance()) == null) {
                    f.writeValue(i.getInstance(), featureDetails)
                }
            }
            i.proceed()
        })
    }
}

Example usage of the extension:

class DataProviderSpec extends Specification {
    @Shared
    FeatureDetails currentFeature

    @Unroll("Test #data.a * 2 = #data.b")
    @ShareFeatureDetails
    def 'test'() {
        when:
        println data

        then:
        data.a * 2 == data.b

        where:
        data << loadData()
    }

    @Unroll("Test #data.a * 3 = #data.b")
    @ShareFeatureDetails
    def 'another test'() {
        when:
        println data

        then:
        data.a * 3 == data.b

        where:
        data << loadData()
    }

    def loadData() {
        // this is hard coded example
        println "${getClass().name}.${currentFeature.name}"
        if ('test' == currentFeature.name) return [[a: 1, b: 2], [a: 2, b: 4]]
        if ('another test' == currentFeature.name) return [[a: 3, b: 9], [a: 4, b: 12]]
        return []
        // ... use load from data file (JSON, YAML, XML, ...) instead:
        // return dataReader.parse("${getClass().name}.json", currentFeature.name)
    }
}

And the output of above example:

DataProviderSpec.test
[a:1, b:2]
[a:2, b:4]
DataProviderSpec.another test
[a:3, b:6]
[a:4, b:8]

First idea was to use only annotated String featureName field in the spec class but there is a problem where visitFeatureAnnotation() method works with different spec instance during each call while loadData() method is executed each time on the first instance.

---

Note: You can also add description with values specific to the current iteration using @Unroll annotation. For example:

@Unroll("Test #data.a * 2 = #data.b")
def 'test'() {
    setup:
    ...
    when:
    ...
    then:
    data.a * 2 == data.b

    where:
    data << getData('test')
}

def getData(String methodName) {
    if ('test' == methodName) return [[a: 1, b: 2], [a: 2, b: 4]]
    ...
}

Will produce:

Test 1 * 2 = 2
Test 2 * 2 = 4

Answer 2

You could use JsonSlurper . It basically parses JSON and returns an Object which could be a List or a Map (just cast it). You can easily use it in your were block (remember to only use static or @Shared in there).

Here is some documentation about JSON in Groovy.

Answer 3

Solved.

The following method, declared in the BaseSpec class, gets the name of current spec automatically on a stage of where block and load params from a config file accordingly:

    protected List<Map<String, Object>> getData() {
        String methodName = StackTraceUtils.sanitize(new Throwable()).stackTrace[1].methodName
        FeatureInfo spec = specificationContext.currentSpec.features.find {
            FeatureInfo info ->
                info.dataProviders.any {
                    it.dataProviderMethod.name == methodName
                }
        }
        Class className = getClass()
        String packageFullName = className.package.name
        String packageName = packageFullName[(packageFullName.lastIndexOf(".") + 1)..-1]
        TestDataReader reader = new JsonReader()
        return reader.parse(packageName, className.simpleName, spec.name)
    }

Usage in class, which is a subclass of BaseSpec class:

def "My custom name spec"() {

    when:
    ... 

    then: 
    ...

    where:
    data << getData()
}