Refactor to enable ingesting a reader directly (#34)

Author: joshdk

ingesters.go

@@ -5,7 +5,8 @@
 package junit
 
 import (
-	"io/ioutil"
+	"bytes"
+	"io"
 	"os"
 	"path/filepath"
 	"strings"
@@ -55,23 +56,24 @@ func IngestFiles(filenames []string) ([]Suite, error) {
 // IngestFile will parse the given XML file and return a slice of all contained
 // JUnit test suite definitions.
 func IngestFile(filename string) ([]Suite, error) {
-	data, err := ioutil.ReadFile(filename)
+	file, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
+	defer file.Close()
 
-	return Ingest(data)
+	return IngestReader(file)
 }
 
-// Ingest will parse the given XML data and return a slice of all contained
-// JUnit test suite definitions.
-func Ingest(data []byte) ([]Suite, error) {
+// IngestReader will parse the given XML reader and return a slice of all
+// contained JUnit test suite definitions.
+func IngestReader(reader io.Reader) ([]Suite, error) {
 	var (
 		suiteChan = make(chan Suite)
 		suites    = make([]Suite, 0)
 	)
 
-	nodes, err := parse(data)
+	nodes, err := parse(reader)
 	if err != nil {
 		return nil, err
 	}
@@ -87,3 +89,9 @@ func Ingest(data []byte) ([]Suite, error) {
 
 	return suites, nil
 }
+
+// Ingest will parse the given XML data and return a slice of all contained
+// JUnit test suite definitions.
+func Ingest(data []byte) ([]Suite, error) {
+	return IngestReader(bytes.NewReader(data))
+}

parse.go

@@ -9,19 +9,24 @@ import (
 	"encoding/xml"
 	"errors"
 	"html"
+	"io"
 )
 
-// reparentXML will wrap the given data (which is assumed to be valid XML), in
-// a fake root nodeAlias.
+// reparentXML will wrap the given reader (which is assumed to be valid XML),
+// in a fake root nodeAlias.
 //
 // This action is useful in the event that the original XML document does not
 // have a single root nodeAlias, which is required by the XML specification.
 // Additionally, Go's XML parser will silently drop all nodes after the first
 // that is encountered, which can lead to data loss from a parser perspective.
 // This function also enables the ingestion of blank XML files, which would
 // normally cause a parsing error.
-func reparentXML(data []byte) []byte {
-	return append(append([]byte("<fake-root>"), data...), "</fake-root>"...)
+func reparentXML(reader io.Reader) io.Reader {
+	return io.MultiReader(
+		bytes.NewReader([]byte("<fake-root>")),
+		reader,
+		bytes.NewReader([]byte("</fake-root>")),
+	)
 }
 
 // extractContent parses the raw contents from an XML node, and returns it in a
@@ -96,10 +101,9 @@ func extractContent(data []byte) ([]byte, error) {
 
 // parse unmarshalls the given XML data into a graph of nodes, and then returns
 // a slice of all top-level nodes.
-func parse(data []byte) ([]xmlNode, error) {
+func parse(reader io.Reader) ([]xmlNode, error) {
 	var (
-		buf  = bytes.NewBuffer(reparentXML(data))
-		dec  = xml.NewDecoder(buf)
+		dec  = xml.NewDecoder(reparentXML(reader))
 		root xmlNode
 	)
 

parse_test.go

@@ -5,8 +5,10 @@
 package junit
 
 import (
+	"bytes"
 	"encoding/xml"
 	"fmt"
+	"io/ioutil"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -39,7 +41,9 @@ func TestReparent(t *testing.T) {
 		name := fmt.Sprintf("#%d - %s", index+1, test.title)
 
 		t.Run(name, func(t *testing.T) {
-			actual := reparentXML(test.input)
+			reader := reparentXML(bytes.NewReader(test.input))
+			actual, err := ioutil.ReadAll(reader)
+			assert.NoError(t, err)
 
 			assert.Equal(t, test.expected, string(actual))
 		})
@@ -168,8 +172,7 @@ func TestParse(t *testing.T) {
 		name := fmt.Sprintf("#%d - %s", index+1, test.title)
 
 		t.Run(name, func(t *testing.T) {
-			actual, err := parse(test.input)
-
+			actual, err := parse(bytes.NewReader(test.input))
 			require.Nil(t, err)
 
 			assert.Equal(t, test.expected, actual)