Add some common test cases for formatters and apply to xml, yaml, and json

Author: stilvoid

formatters/json.go

@@ -1,28 +1,15 @@
 package formatters
 
 import (
-	"fmt"
+	"encoding/json"
 
-	"github.com/nytlabs/mxj"
 	"github.com/stilvoid/please/util"
 )
 
 func formatJSON(in interface{}) (string, error) {
 	in = util.ForceStringKeys(in)
 
-	inMap, ok := in.(map[string]interface{})
+	bytes, err := json.MarshalIndent(in, "", "  ")
 
-	if !ok {
-		return fmt.Sprintf("\"%s\"", in), nil
-	}
-
-	m := mxj.Map(inMap)
-
-	bytes, err := m.JsonIndent("", "  ")
-
-	if err != nil {
-		return "", err
-	}
-
-	return string(bytes), nil
+	return string(bytes), err
 }

formatters/json_test.go

@@ -0,0 +1,37 @@
+package formatters
+
+import "testing"
+
+func TestJSON(t *testing.T) {
+	expecteds := []string{
+		"123",
+		"456.789",
+		"\"abc\"",
+		"true",
+		"false",
+		"null",
+		"[\n  123,\n  \"abc\"\n]",
+		"{\n  \"foo\": \"bar\"\n}",
+		"{\n  \"123\": [\n    \"baz\",\n    \"quux\"\n  ]\n}",
+		"{\n  \"true\": {\n    \"null\": null\n  }\n}",
+		"[\n  456,\n  \"def\",\n  {\n    \"3\": 4\n  }\n]",
+	}
+
+	if len(expecteds) != len(testCases) {
+		t.Fatalf("insufficient test cases implemented")
+	}
+
+	for i, expected := range expecteds {
+		testCase := testCases[i]
+
+		actual, err := formatJSON(testCase)
+
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		if actual != expected {
+			t.Errorf("unexpected '%v', want '%v'", actual, expected)
+		}
+	}
+}

formatters/test.go

@@ -0,0 +1,29 @@
+package formatters
+
+var testCases = []interface{}{
+	123,
+	456.789,
+	"abc",
+	true,
+	false,
+	nil,
+	[]interface{}{123, "abc"},
+	map[interface{}]interface{}{ // A map
+		"foo": "bar", // To a value
+	},
+	map[interface{}]interface{}{ // A map
+		123: []interface{}{"baz", "quux"}, // To an array
+	},
+	map[interface{}]interface{}{ // A map
+		true: map[interface{}]interface{}{ // To another map
+			nil: nil,
+		},
+	},
+	[]interface{}{ // An array
+		456, // Of values
+		"def",
+		map[interface{}]interface{}{ // With a map
+			3: 4,
+		},
+	},
+}

formatters/xml.go

@@ -1,13 +1,19 @@
 package formatters
 
 import (
+	"reflect"
+
 	"github.com/clbanning/anyxml"
 	"github.com/stilvoid/please/util"
 )
 
 func formatXML(in interface{}) (string, error) {
 	in = util.ForceStringKeys(in)
 
+	if reflect.TypeOf(in) == nil {
+		in = ""
+	}
+
 	bytes, err := anyxml.XmlIndent(in, "", "  ")
 
 	if err != nil {

formatters/xml_test.go

@@ -0,0 +1,37 @@
+package formatters
+
+import "testing"
+
+func TestXML(t *testing.T) {
+	expecteds := []string{
+		"<doc>123</doc>",
+		"<doc>456.789</doc>",
+		"<doc>abc</doc>",
+		"<doc>true</doc>",
+		"<doc>false</doc>",
+		"<doc></doc>",
+		"<doc>\n  <element>123</element>\n  <element>abc</element>\n</doc>",
+		"<foo>bar</foo>",
+		"<doc>\n  <123>baz</123>\n  <123>quux</123>\n</doc>",
+		"<true>\n<null/>\n</true>",
+		"<doc>\n  <element>456</element>\n  <element>def</element>\n  <3>4</3>\n</doc>",
+	}
+
+	if len(expecteds) != len(testCases) {
+		//t.Fatalf("insufficient test cases implemented")
+	}
+
+	for i, expected := range expecteds {
+		testCase := testCases[i]
+
+		actual, err := formatXML(testCase)
+
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		if actual != expected {
+			t.Errorf("unexpected '%v', want '%v'", actual, expected)
+		}
+	}
+}

formatters/yaml.go

@@ -1,18 +1,10 @@
 package formatters
 
-import (
-	"github.com/stilvoid/please/util"
-	"gopkg.in/yaml.v2"
-)
+import "gopkg.in/yaml.v2"
 
 func formatYAML(in interface{}) (string, error) {
-	in = util.ForceStringKeys(in)
-
 	bytes, err := yaml.Marshal(in)
 
-	if err != nil {
-		return "", err
-	}
-
-	return string(bytes), nil
+	// We strip off the trailing newline that yaml.v2 seems to insist on
+	return string(bytes[:len(bytes)-1]), err
 }

formatters/yaml_test.go

@@ -0,0 +1,37 @@
+package formatters
+
+import "testing"
+
+func TestYAML(t *testing.T) {
+	expecteds := []string{
+		"123",
+		"456.789",
+		"abc",
+		"true",
+		"false",
+		"null",
+		"- 123\n- abc",
+		"foo: bar",
+		"123:\n- baz\n- quux",
+		"true:\n  null: null",
+		"- 456\n- def\n- 3: 4",
+	}
+
+	if len(expecteds) != len(testCases) {
+		t.Fatalf("insufficient test cases implemented")
+	}
+
+	for i, expected := range expecteds {
+		testCase := testCases[i]
+
+		actual, err := formatYAML(testCase)
+
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		if actual != expected {
+			t.Errorf("unexpected '%v', want '%v'", actual, expected)
+		}
+	}
+}

util/filter_test.go

@@ -12,17 +12,22 @@ func TestFilter(t *testing.T) {
 		"top": "I am the top",
 		"bottom": map[int]interface{}{
 			16: "left",
-			13: []string{
+			13: []interface{}{
 				"right 1",
-				"right 2",
+				map[string]interface{}{
+					"deeper": "we go",
+				},
 			},
 		},
 	}
 
 	cases := map[string]interface{}{
 		"top":         "I am the top",
-		"bottom.16":   "left",
-		"bottom.13.1": "right 2",
+		"bottom":      input["bottom"],
+		"bottom.16":   input["bottom"].(map[int]interface{})[16],
+		"bottom.13":   input["bottom"].(map[int]interface{})[13],
+		"bottom.13.0": input["bottom"].(map[int]interface{})[13].([]interface{})[0],
+		"bottom.13.1": input["bottom"].(map[int]interface{})[13].([]interface{})[1],
 	}
 
 	for path, expected := range cases {
@@ -32,7 +37,7 @@ func TestFilter(t *testing.T) {
 			t.Fail()
 		}
 
-		if expected != actual {
+		if !reflect.DeepEqual(actual, expected) {
 			t.Errorf("case failed: %v vs %v", expected, actual)
 		}
 	}

util/map.go

@@ -14,8 +14,15 @@ func ForceStringKeys(in interface{}) interface{} {
 	case reflect.Map:
 		newMap := make(map[string]interface{}, val.Len())
 
+		var stringKey string
+
 		for _, key := range val.MapKeys() {
-			stringKey := fmt.Sprint(key.Interface())
+			if reflect.TypeOf(key.Interface()) == nil {
+				stringKey = "null"
+			} else {
+				stringKey = fmt.Sprint(key.Interface())
+			}
+
 			newMap[stringKey] = ForceStringKeys(val.MapIndex(key).Interface())
 		}
 

util/map_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func TestForceStringKeys(t *testing.T) {
-	input := map[int]interface{}{
+	input := map[interface{}]interface{}{
 		13: []interface{}{
 			"foo",
 			map[int]interface{}{
@@ -18,6 +18,7 @@ func TestForceStringKeys(t *testing.T) {
 			1: []interface{}{"foo", "bar"},
 			2: "two",
 		},
+		nil: "derf",
 	}
 
 	expected := map[string]interface{}{
@@ -32,6 +33,7 @@ func TestForceStringKeys(t *testing.T) {
 			"1": []interface{}{"foo", "bar"},
 			"2": "two",
 		},
+		"null": "derf",
 	}
 
 	actual := ForceStringKeys(input)