Gherkin data table equivalent in Spock framework?

[HaaiHenkie]

In Spock framework data driven testing, for every row in a data table the feature method will be repeated with the values in that row. To my understanding that is equivalent to Gherkins examples in a scenario outline.
In Gherkin a data table has a different meaning: it passes a list of values to a step definition. I have been looking for an equivalent for this in the Spock framework documentation, but I could not find it. So, does such an equivalent not exist?
I have now solved it by a list of groovy maps which is also quite readable.

[Vampire]

Can you please show an example of

• how a "Gherkin example in a scenario outline" looks and what this results in
• how a "Gherkin data table" looks and what this results in
• how you solved it with Groovy maps

Maybe then someone can suggest something.
I guess most people here are not familiar with Gherkin.
I am not at least. :-)

[HaaiHenkie]

Certainly!

Here is a Gherkin scenario I wrote for my tests:

Scenario: S3.1.2 Archive completed actions in descendants of selected node
  Given "GTD.mm" has the following nodes:
    | position  | type             | text        |
    | node1     | regular          | Household   |
    | node1.1   | project          | Dinner      |
    | node1.1.1 | completed action | Shop        |
    | node1.1.2 | next action      | Cook        |
    | node1.2   | project          | Finances    |
    | node1.2.1 | next action      | Pay bills   |
    | node1.2.2 | completed action | Make budget |
    | node2     | regular          | Study       |
    | node2.1   | project          | Exam        |
    | node2.1.1 | completed action | Read book   |
  And "Archive.mm" has no nodes
  When I archive node1 in "GTD.mm"
  Then "GTD.mm" should have the following nodes:
    | position  | type             | text        |
    | node1     | regular          | Household   |
    | node1.1   | project          | Dinner      |
    | node1.1.1 | next action      | Cook        |
    | node1.2   | project          | Finances    |
    | node1.2.1 | next action      | Pay bills   |
    | node2     | regular          | Study       |
    | node2.1   | project          | Exam        |
    | node2.1.1 | completed action | Read book   |
  And "Archive.mm" should have the following nodes:
    | position  | type             | text        |
    | node1     | regular          | Household   |
    | node1.1   | project          | Dinner      |
    | node1.1.1 | completed action | Shop        |
    | node1.2   | project          | Finances    |
    | node1.2.1 | completed action | Make budget |
  And I should receive the following information:
    """
    2 completed actions are archived.
    """

You can find Gherkin data tables in the steps Given, Then and the following And. They look exactly like a Spock data table, but the function is different: they define a list of data that is input for the step. In this case the data tables describe a list of nodes that are present in a mind map in the given situation and lists of nodes that should be present in mind maps in the Then situation.

This is how I solved it for the given: situation in Spock framework. I created list of maps. It is more verbose than a table but still quite readable. I wrote a class MindMapPopulator that can populate a mind map with the defined nodes. The variable gtdMindMap represents the mind map "GTD.mm" that has been created in setup(). Thus the desired given situation is established.

def "S3.1.2 Archive completed actions in descendants of selected node"() {
  given: '"GTD.mm" has the following nodes:'
    def nodeList = [
      [position:"node1",     type:"regular",          text:"Household"],
      [position:"node1.1",   type:"project",          text:"Dinner"],
      [position:"node1.1.1", type:"completed action", text:"Shop"],
      [position:"node1.1.2", type:"next action",      text:"Cook"],
      [position:"node1.2",   type:"project",          text:"Finances"],
      [position:"node1.2.1", type:"next action",      text:"Pay bills"],
      [position:"node1.2.2", type:"completed action", text:"Make budget"],
      [position:"node2",     type:"regular",          text:"Study"],
      [position:"node2.1",   type:"project",          text:"Exam"],
      [position:"node2.1.1", type:"completed action", text:"Read book"]
    ]
    def mindMapPopulator = new MindMapPopulator(gtdMindMap, nodeList)
  // For simplicity the rest of the feature method is left out
}

[HaaiHenkie]

Here is an example of a Scenario Outline in Gherkin.

Scenario Outline: eating
  Given there are <start> cucumbers
  When I eat <eat> cucumbers
  Then I should have <left> cucumbers

  Examples:
    | start | eat | left |
    |    12 |   5 |    7 |
    |    20 |   5 |   15 |

The Examples: part also looks like a Spock data table and has the same function: the Scenario Outline is repeated for every row in the table. That's why I say it is equivalent to the Spock data table. The difference is that Spock uses an expected: and where: construction instead of a comparable given:, when: and then: construction.

[Vampire]

Ah, I see, thanks for the clarification.

Yeah, a Spock datatable is like a Gherkin Example then.
While in Spock you have more possibilities to define the "rows" than only the data table.
The where: is practially like the Examples:.

I don't know what you mean with "that Spock uses an expected: construction instead of comparable given:, when: and then: construction.
Assuming you mean expect: when you say expected:, then you might have misunderstood something.

You can use expect: like expect: sut.calculateCount() == 1 or you can use when: def count = sut.calculateCount(); then: count == 1,
whether you use a data-driven feature (the ones with where:) or just a simple feature, and you can always use given:. You can also mix expect: and when:/then: in the same feature without problems.

Regarding the Gherkin data table, no, there is no syntactical equivalent in Spock specifically.
But this is also not really necessary, as you have a full turing-complete programming language at hand.
So you can read the data from a file, or you can use those list of maps that you used, or any other way.
You could even use a Groovy AST transformation that runs before the Spock AST transformation, building your own DSL to writ such a table and that transforms it for further usage on compilation, but that is quite non-trivial and you probably don't want to go that route.
But other than that you have all possibilites at hand, for example you could write an own parser method like this:

def foo() {
    given:
        def listOfMaps = parseDateTableToListOfMaps '''
            | position  | type             | text        |
            | node1     | regular          | Household   |
            | node1.1   | project          | Dinner      |
            | node1.1.1 | completed action | Shop        |
            | node1.1.2 | next action      | Cook        |
            | node1.2   | project          | Finances    |
            | node1.2.1 | next action      | Pay bills   |
            | node1.2.2 | completed action | Make budget |
            | node2     | regular          | Study       |
            | node2.1   | project          | Exam        |
            | node2.1.1 | completed action | Read book   |
        '''

    expect:
        true
}

def parseDateTableToListOfMaps(String table) {
    def lines = table.trim().readLines()*.split(/\s*+\|\s*+/)*.drop(1)
    def keys = lines.first()
    return lines.drop(1).collect {
        [keys, it].transpose().collectEntries()
    }
}

Or you can also use any library out there that can help you with your task, like depending on com.xlson.groovycsv:groovycsv and then doing

def foo() {
    given:
        def listOfMaps = parseDateTableToListOfMaps '''
            position  | type             | text
            node1     | regular          | Household
            node1.1   | project          | Dinner
            node1.1.1 | completed action | Shop
            node1.1.2 | next action      | Cook
            node1.2   | project          | Finances
            node1.2.1 | next action      | Pay bills
            node1.2.2 | completed action | Make budget
            node2     | regular          | Study
            node2.1   | project          | Exam
            node2.1.1 | completed action | Read book
        '''

    expect:
        true
}

def parseDateTableToListOfMaps(String table) {
    parseCsv(skipLines: 1, trimWhitespaceFromColumnNames: true, separator: '|', table)
            .collect()
            *.toMap()
            *.collectEntries { key, value -> [key, value.trim()] }
}

[HaaiHenkie]

Thank you, Björn,

I meant expect: instead of expected:. I wrote it down from memory, but did not remember correctly.

Thank you for your answers. I will certainly apply one of them or something similar.