Change YAML test data to encode expectations directly (#34)

Author: aslakhellesoy

go/ast.go

@@ -24,11 +24,11 @@ const (
 )
 
 type node struct {
-	NodeType nodeType `json:"type"`
-	Start    int      `json:"start"`
-	End      int      `json:"end"`
-	Token    string   `json:"token"`
-	Nodes    []node   `json:"nodes"`
+	NodeType nodeType `yaml:"type"`
+	Start    int      `yaml:"start"`
+	End      int      `yaml:"end"`
+	Token    string   `yaml:"token"`
+	Nodes    []node   `yaml:"nodes"`
 }
 
 func (node node) text() string {
@@ -60,10 +60,10 @@ const (
 )
 
 type token struct {
-	Text      string    `json:"text"`
-	TokenType tokenType `json:"type"`
-	Start     int       `json:"start"`
-	End       int       `json:"end"`
+	Text      string    `yaml:"text"`
+	TokenType tokenType `yaml:"type"`
+	Start     int       `yaml:"start"`
+	End       int       `yaml:"end"`
 }
 
 var nullNode = node{textNode, -1, -1, "", nil}

go/cucumber_expression_parser_test.go

@@ -1,20 +1,24 @@
 package cucumberexpressions
 
 import (
-	"encoding/json"
 	"fmt"
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 	"io/ioutil"
 	"testing"
 )
 
+type AstExpectation struct {
+	Expression  string `yaml:"expression"`
+	ExpectedAst node   `yaml:"expected_ast"`
+	Exception   string `yaml:"exception"`
+}
+
 func TestCucumberExpressionParser(t *testing.T) {
 	var assertAst = func(t *testing.T, expected node, expression string) {
 		ast, err := parse(expression)
 		require.NoError(t, err)
 		require.Equal(t, expected, ast)
-		require.Equal(t, expected, ast)
 	}
 	var assertThrows = func(t *testing.T, expected string, expression string) {
 		_, err := parse(expression)
@@ -30,15 +34,12 @@ func TestCucumberExpressionParser(t *testing.T) {
 		contents, err := ioutil.ReadFile(directory + file.Name())
 		require.NoError(t, err)
 		t.Run(fmt.Sprintf("%s", file.Name()), func(t *testing.T) {
-			var expectation expectation
+			var expectation AstExpectation
 			err = yaml.Unmarshal(contents, &expectation)
 			require.NoError(t, err)
 
 			if expectation.Exception == "" {
-				var node node
-				err = json.Unmarshal([]byte(expectation.Expected), &node)
-				require.NoError(t, err)
-				assertAst(t, node, expectation.Expression)
+				assertAst(t, expectation.ExpectedAst, expectation.Expression)
 			} else {
 				assertThrows(t, expectation.Exception, expectation.Expression)
 			}

go/cucumber_expression_test.go

@@ -1,34 +1,38 @@
 package cucumberexpressions
 
 import (
-	"encoding/json"
 	"fmt"
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 	"io/ioutil"
 	"reflect"
 	"regexp"
-	"strings"
 	"testing"
 )
 
+type ExpressionExpectation struct {
+	Expression   string        `yaml:"expression"`
+	Text         string        `yaml:"text"`
+	ExpectedArgs []interface{} `yaml:"expected_args"`
+	Exception    string        `yaml:"exception"`
+}
+
+type RegexExpectation struct {
+	Expression    string `yaml:"expression"`
+	ExpectedRegex string `yaml:"expected_regex"`
+}
+
 func TestCucumberExpression(t *testing.T) {
 
 	t.Run("acceptance tests pass", func(t *testing.T) {
 
-		assertMatches := func(t *testing.T, expected string, expr string, text string) {
+		assertMatches := func(t *testing.T, expectedArgs []interface{}, expr string, text string) {
 			parameterTypeRegistry := NewParameterTypeRegistry()
 			expression, err := NewCucumberExpression(expr, parameterTypeRegistry)
 			require.NoError(t, err)
 			args, err := expression.Match(text)
 			require.NoError(t, err)
-
-			values := strings.Builder{}
-			encoder := json.NewEncoder(&values)
-			encoder.SetEscapeHTML(false)
-			err = encoder.Encode(argumentValues(args))
-			require.NoError(t, err)
-			require.Equal(t, expected, strings.TrimSuffix(values.String(), "\n"))
+			require.Equal(t, expectedArgs, argumentValues(args))
 		}
 
 		assertThrows := func(t *testing.T, expected string, expr string, text string) {
@@ -53,11 +57,11 @@ func TestCucumberExpression(t *testing.T) {
 			contents, err := ioutil.ReadFile(directory + file.Name())
 			require.NoError(t, err)
 			t.Run(fmt.Sprintf("%s", file.Name()), func(t *testing.T) {
-				var expectation expectation
+				var expectation ExpressionExpectation
 				err = yaml.Unmarshal(contents, &expectation)
 				require.NoError(t, err)
 				if expectation.Exception == "" {
-					assertMatches(t, expectation.Expected, expectation.Expression, expectation.Text)
+					assertMatches(t, expectation.ExpectedArgs, expectation.Expression, expectation.Text)
 				} else {
 					assertThrows(t, expectation.Exception, expectation.Expression, expectation.Text)
 				}
@@ -79,25 +83,23 @@ func TestCucumberExpression(t *testing.T) {
 			contents, err := ioutil.ReadFile(directory + file.Name())
 			require.NoError(t, err)
 			t.Run(fmt.Sprintf("%s", file.Name()), func(t *testing.T) {
-				var expectation expectation
+				var expectation RegexExpectation
 				err = yaml.Unmarshal(contents, &expectation)
 				require.NoError(t, err)
-				assertRegex(t, expectation.Expected, expectation.Expression)
+				assertRegex(t, expectation.ExpectedRegex, expectation.Expression)
 			})
 		}
 	})
 
 	t.Run("documents expression generation", func(t *testing.T) {
 		parameterTypeRegistry := NewParameterTypeRegistry()
 
-		/// [capture-match-arguments]
 		expr := "I have {int} cuke(s)"
 		expression, err := NewCucumberExpression(expr, parameterTypeRegistry)
 		require.NoError(t, err)
 		args, err := expression.Match("I have 7 cukes")
 		require.NoError(t, err)
 		require.Equal(t, args[0].GetValue(), 7)
-		/// [capture-match-arguments]
 	})
 
 	t.Run("matches float", func(t *testing.T) {
@@ -185,7 +187,6 @@ func TestCucumberExpression(t *testing.T) {
 		require.NoError(t, err)
 		err = parameterTypeRegistry.DefineParameterType(colorParameterType)
 
-		/// [capture-match-arguments]
 		expr := "{textAndOrNumber}"
 		expression, err := NewCucumberExpression(expr, parameterTypeRegistry)
 		require.NoError(t, err)
@@ -197,7 +198,6 @@ func TestCucumberExpression(t *testing.T) {
 		numArgs, err := expression.Match(num)
 		require.NoError(t, err)
 		require.Equal(t, numArgs[0].GetValue(), []*string{nil, &num})
-		/// [capture-match-arguments]
 	})
 }
 

go/cucumber_expression_tokenizer_test.go

@@ -1,19 +1,17 @@
 package cucumberexpressions
 
 import (
-	"encoding/json"
 	"fmt"
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 	"io/ioutil"
 	"testing"
 )
 
-type expectation struct {
-	Expression string `yaml:"expression"`
-	Text       string `yaml:"text"`
-	Expected   string `yaml:"expected"`
-	Exception  string `yaml:"exception"`
+type TokenExpectation struct {
+	Expression     string  `yaml:"expression"`
+	ExpectedTokens []token `yaml:"expected_tokens"`
+	Exception      string  `yaml:"exception"`
 }
 
 func TestCucumberExpressionTokenizer(t *testing.T) {
@@ -26,15 +24,12 @@ func TestCucumberExpressionTokenizer(t *testing.T) {
 		contents, err := ioutil.ReadFile(directory + file.Name())
 		require.NoError(t, err)
 		t.Run(fmt.Sprintf("%s", file.Name()), func(t *testing.T) {
-			var expectation expectation
+			var expectation TokenExpectation
 			err = yaml.Unmarshal(contents, &expectation)
 			require.NoError(t, err)
 
 			if expectation.Exception == "" {
-				var token []token
-				err = json.Unmarshal([]byte(expectation.Expected), &token)
-				require.NoError(t, err)
-				assertTokenizes(t, token, expectation.Expression)
+				assertTokenizes(t, expectation.ExpectedTokens, expectation.Expression)
 			} else {
 				assertThrows(t, expectation.Exception, expectation.Expression)
 			}

java/pom.xml

@@ -45,12 +45,6 @@
             <artifactId>apiguardian-api</artifactId>
             <version>1.1.2</version>
         </dependency>
-        <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>2.8.8</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest</artifactId>

java/src/main/java/io/cucumber/cucumberexpressions/Ast.java

@@ -46,7 +46,6 @@ private Node(Type type, int start, int end, List<Node> nodes, String token) {
             this.token = token;
             this.start = start;
             this.end = end;
-
         }
 
         enum Type {

java/src/test/java/io/cucumber/cucumberexpressions/AstExpectation.java

@@ -0,0 +1,52 @@
+package io.cucumber.cucumberexpressions;
+
+import io.cucumber.cucumberexpressions.Ast.Node;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.params.converter.ArgumentConversionException;
+import org.junit.jupiter.params.converter.ArgumentConverter;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static java.nio.file.Files.newInputStream;
+
+class AstExpectation {
+    public String expression;
+    public YamlableNode expected_ast;
+    public String exception;
+
+    static class Converter implements ArgumentConverter {
+        Yaml yaml = new Yaml();
+
+        @Override
+        public AstExpectation convert(Object source, ParameterContext context) throws ArgumentConversionException {
+            try {
+                Path path = (Path) source;
+                InputStream inputStream = newInputStream(path);
+                return yaml.loadAs(inputStream, AstExpectation.class);
+            } catch (IOException e) {
+                throw new ArgumentConversionException("Could not load " + source, e);
+            }
+        }
+    }
+
+    static class YamlableNode {
+        public Ast.Node.Type type;
+        public List<YamlableNode> nodes;
+        public String token;
+        public int start;
+        public int end;
+
+        public Node toNode() {
+            if (token != null) {
+                return new Node(type, start, end, token);
+            } else {
+                return new Node(type, start, end, nodes.stream().map(YamlableNode::toNode).collect(Collectors.toList()));
+            }
+        }
+    }
+}

java/src/test/java/io/cucumber/cucumberexpressions/CucumberExpressionParserTest.java

@@ -30,15 +30,15 @@ private static List<Path> acceptance_tests_pass() throws IOException {
 
     @ParameterizedTest
     @MethodSource
-    void acceptance_tests_pass(@ConvertWith(FileToExpectationConverter.class) Expectation expectation) {
-        if (expectation.getException() == null) {
-            Node node = parser.parse(expectation.getExpression());
-            assertThat(node.toString(), is(expectation.getExpected()));
+    void acceptance_tests_pass(@ConvertWith(AstExpectation.Converter.class) AstExpectation expectation) {
+        if (expectation.exception == null) {
+            Node node = parser.parse(expectation.expression);
+            assertThat(node, is(expectation.expected_ast.toNode()));
         } else {
             CucumberExpressionException exception = assertThrows(
                     CucumberExpressionException.class,
-                    () -> parser.parse(expectation.getExpression()));
-            assertThat(exception.getMessage(), is(expectation.getException()));
+                    () -> parser.parse(expectation.expression));
+            assertThat(exception.getMessage(), is(expectation.exception));
         }
     }