plc4go/spi/testutils/ParserSerializerTestRunner.go - plc4x - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package testutils

 import (
 	"context"
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
 	"os"
 	"runtime/debug"
 	"strconv"
 	"strings"
 	"testing"

 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/subchen/go-xmldom"

 	"github.com/apache/plc4x/plc4go/spi/options"
 	"github.com/apache/plc4x/plc4go/spi/utils"
 )

 type ParserSerializerTestsuite struct {
 	name             string
 	protocolName     string
 	outputFlavor     string
 	driverParameters map[string]string
 	byteOrder        binary.ByteOrder
 	parser           Parser
 	rootTypeParser   func(utils.ReadBufferByteBased) (any, error)
 	testcases        []ParserSerializerTestcase
 }

 type ParserSerializerTestcase struct {
 	name            string
 	rawInputText    string
 	rootType        string
 	referenceXml    string
 	parserArguments []string
 }

 func (p *ParserSerializerTestsuite) Run(t *testing.T, testcase ParserSerializerTestcase) error {
 	t.Logf("running testsuite: %s test: %s", p.name, testcase.name)

 	// Get the raw input by decoding the hex-encoded binary input
 	t.Log("decoding input")
 	rawInput, err := hex.DecodeString(testcase.rawInputText)
 	if err != nil {
 		return errors.Wrap(err, "Error decoding test input")
 	}

 	// Create the right read buffer
 	t.Log("creating read buffer")
 	var readBuffer utils.ReadBuffer
 	if p.byteOrder == binary.LittleEndian {
 		readBuffer = utils.NewReadBufferByteBased(rawInput, utils.WithByteOrderForReadBufferByteBased(binary.LittleEndian))
 	} else {
 		readBuffer = utils.NewReadBufferByteBased(rawInput)
 	}

 	// Parse the input according to the settings of the testcase
 	t.Log("parsing input")
 	msg, err := p.parser.Parse(testcase.rootType, testcase.parserArguments, readBuffer)
 	if err != nil {
 		return errors.Wrap(err, "Error parsing input data")
 	}
 	t.Logf("Parsed Message(%T)", msg)
 	t.Logf("\n%s", msg)

 	t.Log("Try serializing")
 	{
 		// First try to use the native xml writer
 		serializable := msg.(utils.Serializable)
 		buffer := utils.NewXmlWriteBuffer()
 		if err := serializable.SerializeWithWriteBuffer(context.Background(), buffer); err == nil {
 			actualXml := buffer.GetXmlString()
 			if err := CompareResults(t, []byte(actualXml), []byte(testcase.referenceXml)); err != nil {
 				border := strings.Repeat("=", 100)
 				fmt.Printf(
 					"\n"+
 						// Border
 						"%[1]s\n"+
 						// Testcase name
 						"%[4]s\n"+
 						// diff detected message
 						"Diff detected\n"+
 						// Border
 						"%[1]s\n"+
 						// xml
 						"%[2]s\n"+
 						// Border
 						"%[1]s\n%[1]s\n"+
 						// Text
 						"Differences were found after parsing (Use the above xml in the testsuite to disable this warning).\n"+
 						// Diff
 						"%[3]s\n"+
 						// Double Border
 						"%[1]s\n%[1]s\n",
 					border,
 					actualXml,
 					err,
 					testcase.name)
 				assert.Equal(t, testcase.referenceXml, actualXml)
 				return errors.Wrap(err, "Error comparing the results")
 			}
 		}
 	}

 	// If all was ok, serialize the object again
 	s, ok := msg.(utils.Serializable)
 	if !ok {
 		return errors.New("Couldn't cast message to Serializable")
 	}
 	t.Log("Serializing went ok")

 	// Create the write buffer
 	t.Log("creating write buffer")
 	var writeBuffer utils.WriteBufferByteBased
 	if p.byteOrder == binary.LittleEndian {
 		writeBuffer = utils.NewWriteBufferByteBased(utils.WithByteOrderForByteBasedBuffer(binary.LittleEndian))
 	} else {
 		writeBuffer = utils.NewWriteBufferByteBased()
 	}

 	// Serialize the message
 	t.Log("Serialize message")
 	err = s.SerializeWithWriteBuffer(context.Background(), writeBuffer)
 	if !ok {
 		return errors.New("Couldn't serialize message back to byte array")
 	}

 	// Check if the output matches in size and content
 	t.Log("comparing output")
 	rawOutput := writeBuffer.GetBytes()
 	if len(rawInput) != len(rawOutput) {
 		t.Errorf("Missmatched number of bytes expected ->%d != %d<-actual\nexpected:\t%x\nactual:\t\t%x", len(rawInput), len(rawOutput), rawInput, rawOutput)
 		t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
 		return errors.New("length doesn't match")
 	}
 	for i, val := range rawInput {
 		if rawOutput[i] != val {
 			t.Error("Raw output doesn't match input at position: " + strconv.Itoa(i))
 			t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
 			return errors.New("index mismatch")
 		}
 	}
 	return nil
 }

 type Parser interface {
 	Parse(typeName string, arguments []string, io utils.ReadBuffer) (any, error)
 }

 func RunParserSerializerTestsuite(t *testing.T, testPath string, parser Parser, options ...options.WithOption) {
 	t.Log("Extract testsuite options")
 	var rootTypeParser func(utils.ReadBufferByteBased) (any, error)
 	skippedTestCasesMap := map[string]bool{}
 	for _, withOption := range options {
 		switch option := withOption.(type) {
 		case withRootTypeParser:
 			t.Logf("Using root type parser for better output")
 			rootTypeParser = option.rootTypeParser
 		case withSkippedTestCases:
 			t.Log("Skipping test cases:")
 			for _, skippedTestCase := range option.skippedTestCases {
 				t.Logf("Skipping %s", skippedTestCase)
 				skippedTestCasesMap[skippedTestCase] = true
 			}
 		}
 	}

 	// Read the test-specification as XML file
 	rootNode := ParseParserSerializerTestSuiteXml(t, testPath)

 	// Parse the contents of the test-specification
 	testsuite := ParseParserSerializerTestSuite(t, *rootNode, parser, rootTypeParser)

 	t.Logf("Running %d testcases", len(testsuite.testcases))
 	for _, testcase := range testsuite.testcases {
 		t.Run(testcase.name, func(t *testing.T) {
 			defer func() {
 				if err := recover(); err != nil {
 					t.Fatalf("\n-------------------------------------------------------\nPanic Failure\n%+v\n%s\n-------------------------------------------------------\n\n", err, debug.Stack())
 				}
 			}()
 			if skippedTestCasesMap[testcase.name] {
 				t.Logf("Testcase %s skipped", testcase.name)
 				t.Skipf("Testcase %s skipped", testcase.name)
 				return
 			}
 			t.Logf("Running testcase %s", testcase.name)
 			if err := testsuite.Run(t, testcase); err != nil {
 				t.Fatalf("\n-------------------------------------------------------\nFailure\n%+v\n-------------------------------------------------------\n\n", err)
 			}
 		})
 	}
 	t.Log("Done running testcases")
 	// Execute the tests in the testsuite
 	t.Log(testsuite.name)
 }

 func ParseParserSerializerTestSuiteXml(t *testing.T, testPath string) *xmldom.Node {
 	// Get the current working directory
 	path, err := os.Getwd()
 	if err != nil {
 		t.Fatal(err)
 	}

 	// Check if the test-file is available
 	dirOffset := "/../../../"
 	testFile := path + dirOffset + testPath
 	info, err := os.Stat(testFile)
 	if os.IsNotExist(err) {
 		t.Logf("Test-File %s doesn't exist", testFile)
 		t.Fatal(err)
 	}
 	if info.IsDir() {
 		t.Logf("Test-File %s refers to a directory", testFile)
 		t.Fatal(err)
 	}

 	// Open a reader for this file
 	dat, err := os.Open(testFile)
 	if err != nil {
 		t.Error("Error opening file")
 	}

 	// Read the xml
 	node := xmldom.Must(xmldom.Parse(dat)).Root
 	return node
 }

 func ParseParserSerializerTestSuite(t *testing.T, node xmldom.Node, parser Parser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) *ParserSerializerTestsuite {
 	if node.Name != "testsuite" {
 		t.Fatal("invalid document structure")
 	}
 	var byteOrder binary.ByteOrder
 	if node.GetAttributeValue("byteOrder") != "LITTLE_ENDIAN" {
 		byteOrder = binary.BigEndian
 	} else {
 		byteOrder = binary.LittleEndian
 	}
 	var testsuiteName string
 	var protocolName string
 	var outputFlavor string
 	driverParameters := make(map[string]string)
 	var testcases []ParserSerializerTestcase
 	for _, childPtr := range node.Children {
 		child := *childPtr
 		switch child.Name {
 		case "name":
 			testsuiteName = child.Text
 		case "protocolName":
 			protocolName = child.Text
 		case "outputFlavor":
 			outputFlavor = child.Text
 		case "driver-parameters":
 			parameterList := child.FindByName("parameter")
 			for _, parameter := range parameterList {
 				nameElement := parameter.FindOneByName("name")
 				valueElement := parameter.FindOneByName("value")
 				if nameElement == nil || valueElement == nil {
 					t.Fatal("invalid parameter found: no present")
 				}
 				name := nameElement.Text
 				value := valueElement.Text
 				if name == "" || value == "" {
 					t.Fatal("invalid parameter found: empty")
 				}
 				driverParameters[name] = value
 			}
 		case "testcase":
 			testcaseName := child.FindOneByName("name").Text
 			rawInputText := (*(child.FindOneByName("raw"))).Text
 			rootType := (*(child.FindOneByName("root-type"))).Text
 			parserArgumentsXml := child.FindOneByName("parser-arguments")
 			var parserArguments []string
 			if parserArgumentsXml != nil {
 				for _, parserArgumentXml := range parserArgumentsXml.Children {
 					parserArguments = append(parserArguments, parserArgumentXml.Text)
 				}
 			}
 			referenceXml := child.FindOneByName("xml")
 			normalizeXml(referenceXml)
 			referenceSerialized := referenceXml.FirstChild().XMLPretty()
 			testcase := ParserSerializerTestcase{
 				name:            testcaseName,
 				rawInputText:    rawInputText,
 				rootType:        rootType,
 				referenceXml:    referenceSerialized,
 				parserArguments: parserArguments,
 			}
 			testcases = append(testcases, testcase)
 		default:
 			t.Fatalf("invalid document structure. Unhandled element %s", child.Name)
 		}
 	}
 	t.Logf("Parsed testsuite name: %s", testsuiteName)

 	return &ParserSerializerTestsuite{
 		name:             testsuiteName,
 		protocolName:     protocolName,
 		outputFlavor:     outputFlavor,
 		driverParameters: driverParameters,
 		byteOrder:        byteOrder,
 		parser:           parser,
 		rootTypeParser:   rootTypeParser,
 		testcases:        testcases,
 	}
 }

 // Mainly remove linebreaks from text content.
 func normalizeXml(input *xmldom.Node) {
 	if len(input.Children) > 0 {
 		for _, child := range input.Children {
 			normalizeXml(child)
 		}
 	}
 	if len(input.Text) > 0 {
 		if strings.Contains(input.Text, "\n") {
 			input.Text = strings.Replace(input.Text, "\n", "", -1)
 		}
 	}
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* https://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package testutils

	import (
	"context"
	"encoding/binary"
	"encoding/hex"
	"fmt"
	"os"
	"runtime/debug"
	"strconv"
	"strings"
	"testing"

	"github.com/pkg/errors"
	"github.com/stretchr/testify/assert"
	"github.com/subchen/go-xmldom"

	"github.com/apache/plc4x/plc4go/spi/options"
	"github.com/apache/plc4x/plc4go/spi/utils"
	)

	type ParserSerializerTestsuite struct {
	name string
	protocolName string
	outputFlavor string
	driverParameters map[string]string
	byteOrder binary.ByteOrder
	parser Parser
	rootTypeParser func(utils.ReadBufferByteBased) (any, error)
	testcases []ParserSerializerTestcase
	}

	type ParserSerializerTestcase struct {
	name string
	rawInputText string
	rootType string
	referenceXml string
	parserArguments []string
	}

	func (p ParserSerializerTestsuite) Run(t testing.T, testcase ParserSerializerTestcase) error {
	t.Logf("running testsuite: %s test: %s", p.name, testcase.name)

	// Get the raw input by decoding the hex-encoded binary input
	t.Log("decoding input")
	rawInput, err := hex.DecodeString(testcase.rawInputText)
	if err != nil {
	return errors.Wrap(err, "Error decoding test input")
	}

	// Create the right read buffer
	t.Log("creating read buffer")
	var readBuffer utils.ReadBuffer
	if p.byteOrder == binary.LittleEndian {
	readBuffer = utils.NewReadBufferByteBased(rawInput, utils.WithByteOrderForReadBufferByteBased(binary.LittleEndian))
	} else {
	readBuffer = utils.NewReadBufferByteBased(rawInput)
	}

	// Parse the input according to the settings of the testcase
	t.Log("parsing input")
	msg, err := p.parser.Parse(testcase.rootType, testcase.parserArguments, readBuffer)
	if err != nil {
	return errors.Wrap(err, "Error parsing input data")
	}
	t.Logf("Parsed Message(%T)", msg)
	t.Logf("\n%s", msg)

	t.Log("Try serializing")
	{
	// First try to use the native xml writer
	serializable := msg.(utils.Serializable)
	buffer := utils.NewXmlWriteBuffer()
	if err := serializable.SerializeWithWriteBuffer(context.Background(), buffer); err == nil {
	actualXml := buffer.GetXmlString()
	if err := CompareResults(t, []byte(actualXml), []byte(testcase.referenceXml)); err != nil {
	border := strings.Repeat("=", 100)
	fmt.Printf(
	"\n"+
	// Border
	"%[1]s\n"+
	// Testcase name
	"%[4]s\n"+
	// diff detected message
	"Diff detected\n"+
	// Border
	"%[1]s\n"+
	// xml
	"%[2]s\n"+
	// Border
	"%[1]s\n%[1]s\n"+
	// Text
	"Differences were found after parsing (Use the above xml in the testsuite to disable this warning).\n"+
	// Diff
	"%[3]s\n"+
	// Double Border
	"%[1]s\n%[1]s\n",
	border,
	actualXml,
	err,
	testcase.name)
	assert.Equal(t, testcase.referenceXml, actualXml)
	return errors.Wrap(err, "Error comparing the results")
	}
	}
	}

	// If all was ok, serialize the object again
	s, ok := msg.(utils.Serializable)
	if !ok {
	return errors.New("Couldn't cast message to Serializable")
	}
	t.Log("Serializing went ok")

	// Create the write buffer
	t.Log("creating write buffer")
	var writeBuffer utils.WriteBufferByteBased
	if p.byteOrder == binary.LittleEndian {
	writeBuffer = utils.NewWriteBufferByteBased(utils.WithByteOrderForByteBasedBuffer(binary.LittleEndian))
	} else {
	writeBuffer = utils.NewWriteBufferByteBased()
	}

	// Serialize the message
	t.Log("Serialize message")
	err = s.SerializeWithWriteBuffer(context.Background(), writeBuffer)
	if !ok {
	return errors.New("Couldn't serialize message back to byte array")
	}

	// Check if the output matches in size and content
	t.Log("comparing output")
	rawOutput := writeBuffer.GetBytes()
	if len(rawInput) != len(rawOutput) {
	t.Errorf("Missmatched number of bytes expected ->%d != %d<-actual\nexpected:\t%x\nactual:\t\t%x", len(rawInput), len(rawOutput), rawInput, rawOutput)
	t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
	return errors.New("length doesn't match")
	}
	for i, val := range rawInput {
	if rawOutput[i] != val {
	t.Error("Raw output doesn't match input at position: " + strconv.Itoa(i))
	t.Errorf("Hexdumps:\n%s", utils.DiffHex(rawInput, rawOutput))
	return errors.New("index mismatch")
	}
	}
	return nil
	}

	type Parser interface {
	Parse(typeName string, arguments []string, io utils.ReadBuffer) (any, error)
	}

	func RunParserSerializerTestsuite(t *testing.T, testPath string, parser Parser, options ...options.WithOption) {
	t.Log("Extract testsuite options")
	var rootTypeParser func(utils.ReadBufferByteBased) (any, error)
	skippedTestCasesMap := map[string]bool{}
	for _, withOption := range options {
	switch option := withOption.(type) {
	case withRootTypeParser:
	t.Logf("Using root type parser for better output")
	rootTypeParser = option.rootTypeParser
	case withSkippedTestCases:
	t.Log("Skipping test cases:")
	for _, skippedTestCase := range option.skippedTestCases {
	t.Logf("Skipping %s", skippedTestCase)
	skippedTestCasesMap[skippedTestCase] = true
	}
	}
	}

	// Read the test-specification as XML file
	rootNode := ParseParserSerializerTestSuiteXml(t, testPath)

	// Parse the contents of the test-specification
	testsuite := ParseParserSerializerTestSuite(t, *rootNode, parser, rootTypeParser)

	t.Logf("Running %d testcases", len(testsuite.testcases))
	for _, testcase := range testsuite.testcases {
	t.Run(testcase.name, func(t *testing.T) {
	defer func() {
	if err := recover(); err != nil {
	t.Fatalf("\n-------------------------------------------------------\nPanic Failure\n%+v\n%s\n-------------------------------------------------------\n\n", err, debug.Stack())
	}
	}()
	if skippedTestCasesMap[testcase.name] {
	t.Logf("Testcase %s skipped", testcase.name)
	t.Skipf("Testcase %s skipped", testcase.name)
	return
	}
	t.Logf("Running testcase %s", testcase.name)
	if err := testsuite.Run(t, testcase); err != nil {
	t.Fatalf("\n-------------------------------------------------------\nFailure\n%+v\n-------------------------------------------------------\n\n", err)
	}
	})
	}
	t.Log("Done running testcases")
	// Execute the tests in the testsuite
	t.Log(testsuite.name)
	}

	func ParseParserSerializerTestSuiteXml(t testing.T, testPath string) xmldom.Node {
	// Get the current working directory
	path, err := os.Getwd()
	if err != nil {
	t.Fatal(err)
	}

	// Check if the test-file is available
	dirOffset := "/../../../"
	testFile := path + dirOffset + testPath
	info, err := os.Stat(testFile)
	if os.IsNotExist(err) {
	t.Logf("Test-File %s doesn't exist", testFile)
	t.Fatal(err)
	}
	if info.IsDir() {
	t.Logf("Test-File %s refers to a directory", testFile)
	t.Fatal(err)
	}

	// Open a reader for this file
	dat, err := os.Open(testFile)
	if err != nil {
	t.Error("Error opening file")
	}

	// Read the xml
	node := xmldom.Must(xmldom.Parse(dat)).Root
	return node
	}

	func ParseParserSerializerTestSuite(t testing.T, node xmldom.Node, parser Parser, rootTypeParser func(utils.ReadBufferByteBased) (any, error)) ParserSerializerTestsuite {
	if node.Name != "testsuite" {
	t.Fatal("invalid document structure")
	}
	var byteOrder binary.ByteOrder
	if node.GetAttributeValue("byteOrder") != "LITTLE_ENDIAN" {
	byteOrder = binary.BigEndian
	} else {
	byteOrder = binary.LittleEndian
	}
	var testsuiteName string
	var protocolName string
	var outputFlavor string
	driverParameters := make(map[string]string)
	var testcases []ParserSerializerTestcase
	for _, childPtr := range node.Children {
	child := *childPtr
	switch child.Name {
	case "name":
	testsuiteName = child.Text
	case "protocolName":
	protocolName = child.Text
	case "outputFlavor":
	outputFlavor = child.Text
	case "driver-parameters":
	parameterList := child.FindByName("parameter")
	for _, parameter := range parameterList {
	nameElement := parameter.FindOneByName("name")
	valueElement := parameter.FindOneByName("value")
	if nameElement == nil \|\| valueElement == nil {
	t.Fatal("invalid parameter found: no present")
	}
	name := nameElement.Text
	value := valueElement.Text
	if name == "" \|\| value == "" {
	t.Fatal("invalid parameter found: empty")
	}
	driverParameters[name] = value
	}
	case "testcase":
	testcaseName := child.FindOneByName("name").Text
	rawInputText := (*(child.FindOneByName("raw"))).Text
	rootType := (*(child.FindOneByName("root-type"))).Text
	parserArgumentsXml := child.FindOneByName("parser-arguments")
	var parserArguments []string
	if parserArgumentsXml != nil {
	for _, parserArgumentXml := range parserArgumentsXml.Children {
	parserArguments = append(parserArguments, parserArgumentXml.Text)
	}
	}
	referenceXml := child.FindOneByName("xml")
	normalizeXml(referenceXml)
	referenceSerialized := referenceXml.FirstChild().XMLPretty()
	testcase := ParserSerializerTestcase{
	name: testcaseName,
	rawInputText: rawInputText,
	rootType: rootType,
	referenceXml: referenceSerialized,
	parserArguments: parserArguments,
	}
	testcases = append(testcases, testcase)
	default:
	t.Fatalf("invalid document structure. Unhandled element %s", child.Name)
	}
	}
	t.Logf("Parsed testsuite name: %s", testsuiteName)

	return &ParserSerializerTestsuite{
	name: testsuiteName,
	protocolName: protocolName,
	outputFlavor: outputFlavor,
	driverParameters: driverParameters,
	byteOrder: byteOrder,
	parser: parser,
	rootTypeParser: rootTypeParser,
	testcases: testcases,
	}
	}

	// Mainly remove linebreaks from text content.
	func normalizeXml(input *xmldom.Node) {
	if len(input.Children) > 0 {
	for _, child := range input.Children {
	normalizeXml(child)
	}
	}
	if len(input.Text) > 0 {
	if strings.Contains(input.Text, "\n") {
	input.Text = strings.Replace(input.Text, "\n", "", -1)
	}
	}
	}