chore: refactor

core/internal/encoding/encoding_test.go

@@ -0,0 +1,118 @@
+package encoding
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTomlToJson(t *testing.T) {
+	tests := []struct {
+		input  string
+		expect string
+	}{
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"\n",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a = \"foo\"\nb = 1\nc = \"${FOO}\"\nd = \"abcd!@#$112\"\n",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.input, func(t *testing.T) {
+			t.Parallel()
+			got, err := TomlToJson([]byte(test.input))
+			assert.NoError(t, err)
+			assert.Equal(t, test.expect, string(got))
+		})
+	}
+}
+
+func TestTomlToJsonError(t *testing.T) {
+	_, err := TomlToJson([]byte("foo"))
+	assert.Error(t, err)
+}
+
+func TestYamlToJson(t *testing.T) {
+	tests := []struct {
+		input  string
+		expect string
+	}{
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112\n",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+		{
+			input:  "a: foo\nb: 1\nc: ${FOO}\nd: abcd!@#$112\n",
+			expect: "{\"a\":\"foo\",\"b\":1,\"c\":\"${FOO}\",\"d\":\"abcd!@#$112\"}\n",
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.input, func(t *testing.T) {
+			t.Parallel()
+			got, err := YamlToJson([]byte(test.input))
+			assert.NoError(t, err)
+			assert.Equal(t, test.expect, string(got))
+		})
+	}
+}
+
+func TestYamlToJsonError(t *testing.T) {
+	_, err := YamlToJson([]byte("':foo"))
+	assert.Error(t, err)
+}
+
+func TestYamlToJsonSlice(t *testing.T) {
+	b, err := YamlToJson([]byte(`foo:
+- bar
+- baz`))
+	assert.NoError(t, err)
+	assert.Equal(t, `{"foo":["bar","baz"]}
+`, string(b))
+}

core/mapping/jsonunmarshaler.go

@@ -11,8 +11,8 @@ const jsonTagKey = "json"
 var jsonUnmarshaler = NewUnmarshaler(jsonTagKey)
 
 // UnmarshalJsonBytes unmarshals content into v.
-func UnmarshalJsonBytes(content []byte, v interface{}) error {
-	return unmarshalJsonBytes(content, v, jsonUnmarshaler)
+func UnmarshalJsonBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
+	return unmarshalJsonBytes(content, v, getJsonUnmarshaler(opts...))
 }
 
 // UnmarshalJsonMap unmarshals content from m into v.
@@ -21,8 +21,8 @@ func UnmarshalJsonMap(m map[string]interface{}, v interface{}, opts ...Unmarshal
 }
 
 // UnmarshalJsonReader unmarshals content from reader into v.
-func UnmarshalJsonReader(reader io.Reader, v interface{}) error {
-	return unmarshalJsonReader(reader, v, jsonUnmarshaler)
+func UnmarshalJsonReader(reader io.Reader, v interface{}, opts ...UnmarshalOption) error {
+	return unmarshalJsonReader(reader, v, getJsonUnmarshaler(opts...))
 }
 
 func getJsonUnmarshaler(opts ...UnmarshalOption) *Unmarshaler {

core/mapping/jsonunmarshaler_test.go

@@ -900,7 +900,9 @@ func TestUnmarshalMap(t *testing.T) {
 			Any string `json:",optional"`
 		}
 
-		err := UnmarshalJsonMap(m, &v)
+		err := UnmarshalJsonMap(m, &v, WithCanonicalKeyFunc(func(s string) string {
+			return s
+		}))
 		assert.Nil(t, err)
 		assert.True(t, len(v.Any) == 0)
 	})

core/mapping/tomlunmarshaler.go

@@ -7,21 +7,21 @@ import (
 )
 
 // UnmarshalTomlBytes unmarshals TOML bytes into the given v.
-func UnmarshalTomlBytes(content []byte, v interface{}) error {
+func UnmarshalTomlBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
 	b, err := encoding.TomlToJson(content)
 	if err != nil {
 		return err
 	}
 
-	return UnmarshalJsonBytes(b, v)
+	return UnmarshalJsonBytes(b, v, opts...)
 }
 
 // UnmarshalTomlReader unmarshals TOML from the given io.Reader into the given v.
-func UnmarshalTomlReader(r io.Reader, v interface{}) error {
+func UnmarshalTomlReader(r io.Reader, v interface{}, opts ...UnmarshalOption) error {
 	b, err := io.ReadAll(r)
 	if err != nil {
 		return err
 	}
 
-	return UnmarshalTomlBytes(b, v)
+	return UnmarshalTomlBytes(b, v, opts...)
 }

core/mapping/tomlunmarshaler_test.go

@@ -1,6 +1,7 @@
 package mapping
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -18,7 +19,7 @@ d = "abcd!@#$112"
 		C string `json:"c"`
 		D string `json:"d"`
 	}
-	assert.Nil(t, UnmarshalTomlBytes([]byte(input), &val))
+	assert.NoError(t, UnmarshalTomlReader(strings.NewReader(input), &val))
 	assert.Equal(t, "foo", val.A)
 	assert.Equal(t, 1, val.B)
 	assert.Equal(t, "${FOO}", val.C)
@@ -37,5 +38,12 @@ d = "abcd!@#$112"
 		C string `json:"c"`
 		D string `json:"d"`
 	}
-	assert.NotNil(t, UnmarshalTomlBytes([]byte(input), &val))
+	assert.Error(t, UnmarshalTomlReader(strings.NewReader(input), &val))
+}
+
+func TestUnmarshalTomlBadReader(t *testing.T) {
+	var val struct {
+		A string `json:"a"`
+	}
+	assert.Error(t, UnmarshalTomlReader(new(badReader), &val))
 }

core/mapping/yamlunmarshaler.go

@@ -1,38 +1,27 @@
 package mapping
 
 import (
-	"errors"
 	"io"
 
 	"github.com/zeromicro/go-zero/core/internal/encoding"
 )
 
-// To make .json & .yaml consistent, we just use json as the tag key.
-const yamlTagKey = "json"
-
-var (
-	// ErrUnsupportedType is an error that indicates the config format is not supported.
-	ErrUnsupportedType = errors.New("only map-like configs are supported")
-
-	yamlUnmarshaler = NewUnmarshaler(yamlTagKey)
-)
-
 // UnmarshalYamlBytes unmarshals content into v.
-func UnmarshalYamlBytes(content []byte, v interface{}) error {
+func UnmarshalYamlBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
 	b, err := encoding.YamlToJson(content)
 	if err != nil {
 		return err
 	}
 
-	return unmarshalJsonBytes(b, v, yamlUnmarshaler)
+	return UnmarshalJsonBytes(b, v, opts...)
 }
 
 // UnmarshalYamlReader unmarshals content from reader into v.
-func UnmarshalYamlReader(reader io.Reader, v interface{}) error {
+func UnmarshalYamlReader(reader io.Reader, v interface{}, opts ...UnmarshalOption) error {
 	b, err := io.ReadAll(reader)
 	if err != nil {
 		return err
 	}
 
-	return UnmarshalYamlBytes(b, v)
+	return UnmarshalYamlBytes(b, v, opts...)
 }

core/mapping/yamlunmarshaler_test.go

@@ -1011,6 +1011,13 @@ func TestUnmarshalYamlMapRune(t *testing.T) {
 	assert.Equal(t, rune(3), v.Machine["node3"])
 }
 
+func TestUnmarshalYamlBadInput(t *testing.T) {
+	var v struct {
+		Any string
+	}
+	assert.Error(t, UnmarshalYamlBytes([]byte("':foo"), &v))
+}
+
 type badReader struct{}
 
 func (b *badReader) Read(_ []byte) (n int, err error) {